wiki-formant 0.84.0 → 0.85.1

package/README.md

@@ -37,9 +37,9 @@ const { items, total } = await store.search('validators', { take: 20 });
 await store.save({ tagPath, slug, content, authorId, message, baseVersion: page.version });
 ```
 
-- **A save is one statement.** The page update and its revision are a data-modifying CTE guarded on the version the save read. A save that lost a race writes nothing and throws a 409 `HttpError`; pass `baseVersion` and a save opened on an old version is refused the same way, instead of erasing the edit in between.
+- **A save is one statement.** The page update and its revision are a data-modifying CTE guarded on the version the save read. A save that lost a race writes nothing and throws a 409 `HttpError`; pass `baseVersion` and a save opened on an old version, or on a page deleted since, is refused the same way, instead of erasing the edit in between or re-creating the page. A rename onto a slug another save took meanwhile is a 409 too.
 - **The bump is the diff's.** Added, removed or moved blocks are `major`, changed prose or title `minor`; `change` overrides it for a script that knows better. A metadata-only save moves no version and writes no revision.
-- **History is diffed on read.** A revision stores the page as it was saved, never a diff, so a script's revision and the editor's carry the same history. `history(pageId, { limit })` reads one row more than it returns, so the oldest entry shown is diffed against its real predecessor.
+- **History is diffed on read.** A revision stores the page as it was saved, never a diff, so a script's revision and the editor's carry the same history. `history(pageId, { limit })` reads one row more than it returns, so the oldest entry shown is diffed against its real predecessor. It and `revision` answer only for a page of the store's own site.
 - **Listings carry a snippet, not the article.** `list`, `recent` and `byIds` drop `content` for one line of it; a category of 200 cards otherwise ships 200 block arrays.
 - **Search is four tiers**: title prefix, title, literal prose, then full text on `search_tsv` with Postgres' own headline as the snippet. Hidden paths are left out unless the search names one; `content: true` keeps each row's blocks.
 - **A path under a hidden one is hidden too**, in every listing, whether or not the tree names it.
@@ -93,7 +93,7 @@ const { items, total } = await searchWiki(reading, 'validators', { page: 1, size
 - Every row carries the page `id` too, which a `pageList` block takes. `get_page` with `blocks: true` returns the stored blocks, the page `id`, its whole metadata and `version`: what an edit starts from. `forEdit` adds what the app's write tool takes beside them, and `authors` names each revision's author in `get_page_history`.
 - `text` should be the serializer the page's markdown twin uses, and `resolve` the resolver its page uses to fill what is read live (a page list's pages): `get_page`, `get_pages` and the default corpus read text through both, so a page reads the same over MCP as at its twin, which `twinParity` checks.
 - `privateHidden` closes the back office to every tool; without it a hidden page is unlisted but readable by path, as its URL is.
-- `metadata`, `label`, `corpus`, `noMatch` and `skills` are the app's: what a row adds, how a category is named, the sections its llms-full.txt is made of, what an empty search says, and the A2A skills.
+- `metadata`, `label`, `corpus`, `noMatch` and `skills` are the app's: what a row adds, how a category is named, the sections `get_full_corpus` slices, what an empty search says, and the A2A skills.
 - Writes stay with each app, because who may write is the one thing no two of them agree on.
 
 ## Taxonomy
@@ -268,7 +268,7 @@ The drift checks hold an MCP server to what its own site does, so a tool cannot
 await versionCoherence(t, server.version, standardVersionSources(t, ['/openapi.json', '/api/openapi.json']), init.result?.serverInfo?.version);
 ```
 
-`descriptorChecks(t)` defaults to `S10_DESCRIPTORS`, the six JSON descriptors every surface here serves, and `distinctEtagChecks(t, ['llms.txt', 'llms-full.txt'])` asserts that depths projecting one corpus carry different ETags — every one present, which a bare Set-size check misses.
+`descriptorChecks(t)` defaults to `S10_DESCRIPTORS`, the six JSON descriptors every surface here serves.
 
 ## Markdown twins
 
@@ -377,7 +377,7 @@ The default `frame-src` is `DEFAULT_IFRAME_HOSTS`, the same list the sanitiser's
 
 `parsePagination` clamps `page ≥ 1` and `pageSize` to 1–100; `paginatedResponse` always carries `totalPages`. Reshaping that response is a breaking change to every client that pages, which is why it lives here rather than being re-typed per repo.
 
-`parseVersion` / `bump` / `compareVersions` handle revision semver tolerantly — a page always has a version, even when the column holds `null` or junk.
+`parseVersion` / `bump` handle revision semver tolerantly — a page always has a version, even when the column holds `null` or junk.
 
 ## React
 
@@ -1185,7 +1185,7 @@ npx fts-ddl pages
 npx fts-ddl '"WikiPage"'
 ```
 
-`mark-verified` stamps `lastVerifiedAt` on pages a sweep checked and found current, so `freshnessBanner` stops calling them outdated, and `maintenance-log` is the state I/O of a wiki-sweep routine whose memory lives in one page's `metadata.state`: `read`, `write` (the whole state, or `-` for stdin), `compact` and `backlog-add`, which appends under a row lock so another routine's item cannot be lost to a concurrent `write`. Every write compacts and re-renders the page, holding at most as many FLAG FOR A HUMAN items as the page shows; a revision is written at most once a day. `write` refuses a state whose `totalRuns` is below the stored one, which is a state read before another run wrote. Both work on the package's own `WikiPage` and `WikiRevision`. Run them from the app's root, like `passkey-invite`:
+`mark-verified` stamps `lastVerifiedAt` on pages a sweep checked and found current, so `freshnessBanner` stops calling them outdated, and `maintenance-log` is the state I/O of a wiki-sweep routine whose memory lives in one page's `metadata.state`: `read`, `write` (the whole state, or `-` for stdin), `compact` and `backlog-add`, which is how another routine files an item. Every mode holds the row lock from read to write, and `backlog-add` records what it filed in `state.filed`, so a `write` of a state read before the filing merges the item back in rather than dropping it (`lateBacklog`). Only `metadata.state` is written; the page's other metadata is kept. Every write compacts and re-renders the page, holding at most as many FLAG FOR A HUMAN items as the page shows; a revision is written at most once a day. `write` refuses a state whose `totalRuns` is below the stored one, which is a state read before another run wrote. Both work on the package's own `WikiPage` and `WikiRevision`. Run them from the app's root, like `passkey-invite`:
 
 ```sh
 npx mark-verified contents/tech/radix-engine scrypto       # one page

package/bin/maintenance-log.mjs

@@ -26,11 +26,12 @@
 // page in place, because a full copy per run is what made radix-wiki's log
 // over half its revisions table. `write` refuses a state whose totalRuns is
 // below the stored one: that state was read before another run wrote.
-// `backlog-add` is how another routine files an
-// item: `write` replaces the whole state, so an append through it could lose a
-// concurrent run's, and the row lock serialises the two. A revision bumps the
-// page's version a minor.
-import { PINNED, addBacklog, compact, render, staleWrite } from '../dist/maintenance.js';
+// `backlog-add` is how another routine files an item. It records what it filed
+// in `state.filed`, and a `write` whose state was read before the filing merges
+// the item back in, so a run's whole-state write cannot drop it. Every mode
+// reads and writes under the row lock. Only `state` in the page's metadata is
+// written; other keys are kept. A revision bumps the page's version a minor.
+import { PINNED, addBacklog, compact, lateBacklog, render, staleWrite } from '../dist/maintenance.js';
 import { bump } from '../dist/versioning.js';
 import { arg, connect, invalidate } from './_cli.mjs';
 
@@ -48,6 +49,8 @@ if (!['read', 'write', 'compact', 'backlog-add'].includes(mode) || slugAt < 1 ||
 const pages = '"WikiPage"';
 const revisions = '"WikiRevision"';
 const where = `"tagPath" = $1 AND slug = $2 AND "siteId" = $3`;
+/** The new state into the page's metadata, beside whatever else it holds. `lastVerified` was a stamp nothing read. */
+const withState = `(metadata - 'lastVerified') || jsonb_build_object('state', $2::jsonb)`;
 const address = [at.slice(0, slugAt), at.slice(slugAt + 1), arg('--site') ?? ''];
 
 const readStdin = async () => {
@@ -79,14 +82,14 @@ try {
       await q('ROLLBACK');
       console.log('  nothing to add (all duplicates)');
     } else {
-      const next = compact({ ...state, backlog: [...(state.backlog ?? []), ...added] });
+      const next = compact({ ...state, backlog: [...(state.backlog ?? []), ...added], filed: [...(state.filed ?? []), ...added.map(a => a.item)] });
       console.log(`  ${dry ? '[dry] ' : ''}+${added.length} backlog item(s), ${next.backlog.length} open`);
       for (const a of added) console.log(`     ${a.item}`);
       if (dry) await q('ROLLBACK');
       else {
-        await q(`UPDATE ${pages} SET content = $1, metadata = $2, "updatedAt" = now() WHERE id = $3`, [
+        await q(`UPDATE ${pages} SET content = $1, metadata = ${withState}, "updatedAt" = now() WHERE id = $3`, [
           JSON.stringify(render(next, routine)),
-          JSON.stringify({ state: next, lastVerified: today }),
+          JSON.stringify(next),
           page.id,
         ]);
         await q('COMMIT');
@@ -94,15 +97,22 @@ try {
       }
     }
   } else {
-    const [page] = await q(`SELECT * FROM ${pages} WHERE ${where}`, address);
+    const text = mode === 'write' ? (payload === undefined || payload === '-' ? await readStdin() : payload) : '';
+    if (mode === 'write' && !text.trim()) throw new Error('write needs the state as JSON, as an argument or on stdin with `write -`');
+    // Locked from the read to the write, so a `backlog-add` lands before or after, never in between.
+    await q('BEGIN');
+    const [page] = await q(`SELECT * FROM ${pages} WHERE ${where} FOR UPDATE`, address);
     if (!page) throw new Error(`no log page at ${at}`);
-    let input = page.metadata?.state ?? {};
+    const stored = page.metadata?.state ?? {};
+    let input = stored;
     if (mode === 'write') {
-      const text = payload === undefined || payload === '-' ? await readStdin() : payload;
-      if (!text.trim()) throw new Error('write needs the state as JSON, as an argument or on stdin with `write -`');
       input = JSON.parse(text);
-      const stale = staleWrite(page.metadata?.state ?? {}, input);
+      const stale = staleWrite(stored, input);
       if (stale) throw new Error(stale);
+      const late = lateBacklog(stored, input, today);
+      for (const l of late) console.log(`  kept, filed since this state was read: ${l.item}`);
+      const { filed: _, ...rest } = input;
+      input = { ...rest, backlog: [...(input.backlog ?? []), ...late] };
     }
     const state = compact(input);
     const content = render(state, routine);
@@ -130,11 +140,11 @@ try {
         `content ${JSON.stringify(content).length} B${revise ? `, revision v${version}` : ', no revision today'}`,
     );
 
-    if (!dry) {
-      await q('BEGIN');
+    if (dry) await q('ROLLBACK');
+    else {
       await q(
-        `UPDATE ${pages} SET content = $1, metadata = $2, "updatedAt" = now(), version = $4 WHERE id = $3`,
-        [JSON.stringify(content), JSON.stringify({ state, lastVerified: today }), page.id, version],
+        `UPDATE ${pages} SET content = $1, metadata = ${withState}, "updatedAt" = now(), version = $4 WHERE id = $3`,
+        [JSON.stringify(content), JSON.stringify(state), page.id, version],
       );
       if (revise) {
         await q(

package/bin/mark-verified.mjs

@@ -29,8 +29,9 @@ try {
   client = await connect();
   const { rowCount } = all
     ? await client.query(
-        `UPDATE "WikiPage" SET "lastVerifiedAt" = now() WHERE "siteId" = $3 AND ("tagPath" = $1 OR "tagPath" LIKE $2)`,
-        [tagPath, `${tagPath}/%`, site],
+        // starts_with, not LIKE: a `_` or `%` in the path would match other branches.
+        `UPDATE "WikiPage" SET "lastVerifiedAt" = now() WHERE "siteId" = $3 AND ("tagPath" = $1 OR starts_with("tagPath", $2))`,
+        [tagPath, `${tagPath}/`, site],
       )
     : await client.query(
         `UPDATE "WikiPage" SET "lastVerifiedAt" = now() WHERE "siteId" = $3 AND "tagPath" = $1 AND slug = $2`,

package/dist/a2a.js

@@ -10,7 +10,7 @@
 //
 // Both revisions in the field are spoken: v0.3 (`message/send`, a Message with
 // `kind`) and v1.0 (`SendMessage`, a `{ message }` with proto-JSON enums).
-import { McpToolError } from './mcp.js';
+import { MCP_LEGACY_PROTOCOL_VERSION, McpToolError } from './mcp.js';
 const SEND = { 'message/send': '0.3', SendMessage: '1.0' };
 /** Task methods: none can succeed, because no task is ever created. */
 const TASK = new Set(['tasks/get', 'tasks/cancel', 'tasks/resubscribe', 'GetTask', 'CancelTask', 'SubscribeToTask']);
@@ -31,7 +31,7 @@ const UNSUPPORTED = new Set([
     'GetExtendedAgentCard',
 ]);
 /** @internal */
-export const isA2aMethod = (method) => method in SEND || TASK.has(method) || UNSUPPORTED.has(method);
+export const isA2aMethod = (method) => Object.hasOwn(SEND, method) || TASK.has(method) || UNSUPPORTED.has(method);
 const error = (id, code, message) => ({ jsonrpc: '2.0', id, error: { code, message } });
 /** The text of a message's text parts, whichever revision shaped them. */
 function textOf(message) {
@@ -53,14 +53,14 @@ async function reply(text, config) {
         const out = await tool.handler({ [config.answer.argument]: text }, {
             meta: {},
             setMeta: () => { },
-            protocolVersion: '2025-11-25',
+            protocolVersion: MCP_LEGACY_PROTOCOL_VERSION,
         });
         const lead = `${config.serverInfo.name} ${tool.name} for ${JSON.stringify(text)}. For more, call this endpoint over MCP: "initialize", then "tools/list".`;
         if (typeof out === 'string')
             return { text: `${lead}\n\n${out}` };
         // The text twin stays beside the data, as it does on an MCP tool result:
         // a client that reads only text parts still has to be able to read the answer.
-        return { text: `${lead}\n\n${JSON.stringify(out, null, 2)}`, ...(out && typeof out === 'object' && !Array.isArray(out) ? { data: out } : {}) };
+        return { text: `${lead}\n\n${JSON.stringify(out ?? null, null, 2)}`, ...(out && typeof out === 'object' && !Array.isArray(out) ? { data: out } : {}) };
     }
     catch (err) {
         if (err instanceof McpToolError)

package/dist/analytics.js

@@ -134,15 +134,18 @@ export async function collect(request, { sql, defer, site, rateLimit: limit = BE
     if (BOT.test(headers.get('user-agent') ?? '') || !rateLimit(clientKey('beacon', headers), limit).ok)
         return done;
     const body = (await request.json().catch(() => null));
-    const path = typeof body?.path === 'string' ? normalisePath(body.path) : null;
-    if (!body || !path)
+    const raw = typeof body?.path === 'string' ? body.path : null;
+    const path = raw === null ? null : normalisePath(raw);
+    if (!body || raw === null || !path)
         return done;
     const key = site ? await site(request, path) : '';
     if (key === null)
         return done;
+    // The recorders normalise what they are given, so they get the path as sent:
+    // decoded twice, `/100%25-off` was dropped and `/what%3Fnow` cut to `/what`.
     defer(() => typeof body.name === 'string' && body.name
-        ? recordEvent(sql, { name: body.name, props: beaconProps(body.props), url: path, headers, site: key })
-        : recordView(sql, { headers, path, referrer: body.referrer, utm: body.utm, site: key }));
+        ? recordEvent(sql, { name: body.name, props: beaconProps(body.props), url: raw, headers, site: key })
+        : recordView(sql, { headers, path: raw, referrer: body.referrer, utm: body.utm, site: key }));
     return done;
 }
 /** Searches in a wiki's own search box that found nothing (`searchQueryProps` events). */

package/dist/block-views.d.ts

@@ -82,7 +82,13 @@ export declare function PageRefsView({ refs, empty, link: Link, renderItem, }: {
  * through its HTML pipeline, and running it in the other would rewrite anchors
  * that were minted under different rules.
  */
-export declare function ReferencesView({ items, title, processHtml, }: {
+export declare function ReferencesView({ id, items, title, processHtml, }: {
+    /**
+     * The block's id, which keys the heading's: `references-<id>`. Without it the
+     * heading is `references-heading`, which a second references block on the
+     * page would repeat, labelling both sections with the first one's heading.
+     */
+    id?: string;
     items?: readonly (ReferenceItem & {
         id?: string;
     })[];

package/dist/block-views.js

@@ -89,11 +89,12 @@ export function PageRefsView({ refs, empty, link: Link = Anchor, renderItem, })
  * through its HTML pipeline, and running it in the other would rewrite anchors
  * that were minted under different rules.
  */
-export function ReferencesView({ items, title = 'References', processHtml = (html) => html, }) {
+export function ReferencesView({ id, items, title = 'References', processHtml = (html) => html, }) {
     const rows = items ?? [];
     if (!rows.length)
         return null;
-    return (_jsxs("section", { className: "references-block", "aria-labelledby": "references-heading", children: [_jsx("h2", { id: "references-heading", children: title }), _jsx("ol", { className: "references-list", children: rows.map((item, i) => {
+    const headingId = id ? `references-${id}` : 'references-heading';
+    return (_jsxs("section", { className: "references-block", "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, children: title }), _jsx("ol", { className: "references-list", children: rows.map((item, i) => {
                     const url = safeLinkHref(item.url);
                     return (_jsxs("li", { id: `ref-${i + 1}`, className: "reference-item", children: [_jsx("a", { href: `#cite-${i + 1}`, className: "ref-backlink", "aria-label": "Back to citation", children: "\u2191" }), ' ', _jsx("span", { dangerouslySetInnerHTML: { __html: processHtml(item.text) } }), url && (_jsxs(_Fragment, { children: [' ', _jsx("a", { href: url, target: "_blank", rel: "noopener", className: "reference-link", "aria-label": "Open source", children: "\u2197" })] }))] }, item.id ?? i));
                 }) })] }));

package/dist/blocks.js

@@ -164,7 +164,10 @@ export function codeTabsToMarkdown(tabs) {
         .map(t => {
         const longest = Math.max(0, ...(t.code.match(/`+/g) ?? []).map(run => run.length));
         const fence = '`'.repeat(Math.max(3, longest + 1));
-        return `**${t.label}**\n\n${fence}${t.language || ''}\n${t.code.trim()}\n${fence}`;
+        // Blank lines go from either end, but not the first line's indentation:
+        // in YAML or Python it is part of the code.
+        const code = t.code.replace(/^\s*\n/, '').trimEnd();
+        return `**${t.label}**\n\n${fence}${t.language || ''}\n${code}\n${fence}`;
     })
         .join('\n\n');
 }

package/dist/conformance.d.ts

@@ -152,16 +152,6 @@ export declare const S10_DESCRIPTORS: readonly string[];
  * validator, and it is enough.
  */
 export declare function descriptorChecks(t: Tester, paths?: readonly string[]): Promise<void>;
-/**
- * Documents that project one corpus at different depths carry different ETags.
- *
- * Depths sharing a validator pass every conditional-GET check and still never
- * move when only one of them changes. Every one must also HAVE an ETag: a Set
- * of three nulls is size one and fails, but one null among two tags would pass
- * a size check alone — the copy of this check one repo carried had exactly
- * that hole.
- */
-export declare function distinctEtagChecks(t: Tester, paths: readonly string[], label?: string): Promise<void>;
 /**
  * Every tool carries behavioural hints, and the ones that write say so.
  *

package/dist/conformance.js

@@ -367,19 +367,6 @@ export async function descriptorChecks(t, paths = S10_DESCRIPTORS) {
         t.check(`${label} states a freshness`, /max-age=\d+/.test(fresh.headers.get('cache-control') ?? ''), `cache-control: ${fresh.headers.get('cache-control')}`);
     }
 }
-/**
- * Documents that project one corpus at different depths carry different ETags.
- *
- * Depths sharing a validator pass every conditional-GET check and still never
- * move when only one of them changes. Every one must also HAVE an ETag: a Set
- * of three nulls is size one and fails, but one null among two tags would pass
- * a size check alone — the copy of this check one repo carried had exactly
- * that hole.
- */
-export async function distinctEtagChecks(t, paths, label = 'llms depths have distinct ETags') {
-    const tags = await Promise.all(paths.map(p => fetch(`${t.base}/${p.replace(/^\//, '')}`).then(r => r.headers.get('etag'))));
-    t.check(label, tags.every(Boolean) && new Set(tags).size === paths.length, tags.join(' '));
-}
 /**
  * Every tool carries behavioural hints, and the ones that write say so.
  *
@@ -452,7 +439,11 @@ export async function payloadBudget(t, calls, maxBytes = 120_000) {
 export async function robotsChecks(t, paths) {
     const body = await (await fetch(`${t.base}/robots.txt`)).text();
     const rules = [];
+    // A group is a run of User-agent lines and the rules after it, so `*` anywhere
+    // in the run takes the group's rules; the next User-agent after a rule opens
+    // a new group.
     let inStar = false;
+    let inRules = false;
     for (const raw of body.split('\n')) {
         const line = raw.replace(/#.*$/, '').trim();
         const [field, ...rest] = line.split(':');
@@ -460,10 +451,15 @@ export async function robotsChecks(t, paths) {
             continue;
         const key = field.trim().toLowerCase();
         const value = rest.join(':').trim();
-        if (key === 'user-agent')
-            inStar = value === '*';
-        else if (inStar && (key === 'allow' || key === 'disallow') && value) {
-            rules.push({ allow: key === 'allow', path: value });
+        if (key === 'user-agent') {
+            if (inRules)
+                [inStar, inRules] = [false, false];
+            inStar ||= value === '*';
+        }
+        else if (key !== 'sitemap') {
+            inRules = true;
+            if (inStar && (key === 'allow' || key === 'disallow') && value)
+                rules.push({ allow: key === 'allow', path: value });
         }
     }
     for (const path of paths) {

package/dist/corpus.js

@@ -1,6 +1,6 @@
 // corpus.ts — a wiki's whole corpus, sliced to something a tool result can hold.
 //
-// /llms-full.txt can afford to be 3 MB: a fetch streams to disk under an ETag.
+// A file export can afford to be 3 MB: a fetch streams to disk under an ETag.
 // A tool result lands in a context window, so the MCP twin of that export needs
 // a preflight, a character budget and a page-aligned resume. Two wikis wrote
 // that loop and called the second a copy of the first "field for field". It was

package/dist/http.js

@@ -151,7 +151,15 @@ export function cacheTagHeaders(tags) {
  */
 export function wantsMarkdown(request) {
     return (new URL(request.url).searchParams.get('format') === 'text' ||
-        /text\/(markdown|plain)/.test(request.headers.get('accept') ?? ''));
+        (request.headers.get('accept') ?? '').split(',').some(acceptsText));
+}
+/** One Accept media range naming markdown or plain text at a weight above zero: `q=0` means "not this". */
+function acceptsText(range) {
+    const [type, ...params] = range.toLowerCase().split(';').map(s => s.replace(/\s/g, ''));
+    if (type !== 'text/markdown' && type !== 'text/plain')
+        return false;
+    const q = params.find(p => p.startsWith('q='));
+    return !q || Number(q.slice(2)) > 0;
 }
 /** The header every response from a content-negotiated URL carries. */
 export const VARY_ACCEPT = { Vary: 'Accept' };
@@ -215,7 +223,9 @@ export function cleanSnippet(text, max = 160) {
 export function pageLine(opts) {
     const excerpt = opts.excerpt ? `: ${cleanSnippet(opts.excerpt)}` : '';
     const stamp = opts.updated ? isoDate(opts.updated) : '';
-    return `- [${opts.title}](${opts.url})${excerpt}${stamp ? ` _(updated ${stamp})_` : ''}`;
+    // A bracket in a title ("[RFC] Fees") would close the link text early.
+    const title = opts.title.replace(/[[\]\\]/g, '\\$&');
+    return `- [${title}](${opts.url})${excerpt}${stamp ? ` _(updated ${stamp})_` : ''}`;
 }
 /**
  * The validators for an aggregate: the ETag seeded from `seed` (the depth or

package/dist/maintenance.d.ts

@@ -36,6 +36,8 @@ export interface LogState {
     backlog?: BacklogEntry[];
     feedback?: FeedbackEntry[];
     runHistory?: RunEntry[];
+    /** What `backlog-add` filed since the last `write`, by item: how a write tells a late item from one it closed. */
+    filed?: string[];
     [key: string]: unknown;
 }
 /** Drops what is closed or a diary entry, and caps what is append-only. Newest first. */
@@ -47,6 +49,15 @@ export declare function compact(state: LogState): LogState;
  * with it silently erases what the later run recorded.
  */
 export declare function staleWrite(stored: LogState, next: LogState): string | null;
+/**
+ * The items another routine filed with `backlog-add` after `next` was read,
+ * which `next` therefore cannot carry: in the stored `filed` list and not in
+ * the one `next` was read with. A run's `write` replaces the whole state, so
+ * without this an item filed mid-run was lost. Merged rather than refused,
+ * because a run that has done its work should not be sent back over another
+ * routine's note.
+ */
+export declare function lateBacklog(stored: LogState, next: LogState, today: string): BacklogEntry[];
 /** 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. */

package/dist/maintenance.js

@@ -67,6 +67,19 @@ export function staleWrite(stored, next) {
         ? `refusing a state with totalRuns ${has} over the stored ${had}: it predates a run that has already written. Read the log again and reapply this run's changes.`
         : null;
 }
+/**
+ * The items another routine filed with `backlog-add` after `next` was read,
+ * which `next` therefore cannot carry: in the stored `filed` list and not in
+ * the one `next` was read with. A run's `write` replaces the whole state, so
+ * without this an item filed mid-run was lost. Merged rather than refused,
+ * because a run that has done its work should not be sent back over another
+ * routine's note.
+ */
+export function lateBacklog(stored, next, today) {
+    const filed = new Set(stored.filed ?? []);
+    const seen = new Set(next.filed ?? []);
+    return addBacklog(next, (stored.backlog ?? []).filter(b => filed.has(itemOf(b)) && !seen.has(itemOf(b))), today);
+}
 /** 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));
@@ -94,9 +107,10 @@ export function render(state, routine, newId = () => crypto.randomUUID()) {
     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);
+        // `v?.`: the state is a routine's own JSON, and `compact` keeps a null entry.
+        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>`;
+        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);

package/dist/markdown.js

@@ -45,7 +45,7 @@ const NAMED_ENTITIES = {
 export function decodeEntities(s) {
     return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{1,9}));/g, (m, hex, dec, name) => {
         if (name)
-            return NAMED_ENTITIES[name] ?? m;
+            return Object.hasOwn(NAMED_ENTITIES, name) ? NAMED_ENTITIES[name] : m;
         const code = hex ? parseInt(hex, 16) : Number(dec);
         return code <= 0x10ffff ? String.fromCodePoint(code) : m;
     });
@@ -146,15 +146,17 @@ export function htmlToMarkdown(html) {
 }
 /** YAML frontmatter block, `---` fences included. */
 export function frontmatter(fields) {
-    const esc = (s) => s.replace(/"/g, '\\"');
+    // A YAML double-quoted scalar: a backslash starts an escape (`\b` is a
+    // backspace) and a raw newline ends the line, so both are escaped with the quote.
+    const esc = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\r?\n/g, '\\n');
     return [
         '---',
         `title: "${esc(fields.title)}"`,
-        `url: "${fields.url}"`,
+        `url: "${esc(fields.url)}"`,
         ...(fields.updated ? [`updated: ${isoDate(fields.updated)}`] : []),
         ...(fields.lastVerified ? [`last_verified: ${isoDate(fields.lastVerified)}`] : []),
         ...(fields.license
-            ? [`license: ${fields.license.spdx}`, `license_url: "${fields.license.url}"`]
+            ? [`license: ${fields.license.spdx}`, `license_url: "${esc(fields.license.url)}"`]
             : []),
         ...Object.entries(fields.extra ?? {})
             .filter(([, v]) => v !== undefined && v !== '')

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.js

@@ -13,6 +13,7 @@
 // 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. */
@@ -31,12 +32,17 @@ export function maintenanceQueues(pages, o) {
     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('/'))
-                linkedPaths.add(target.replace(/\/+$/, '') || '/');
+            if (target.startsWith('/')) {
+                const path = target.replace(/\/+$/, '') || '/';
+                if (path !== self)
+                    linkedPaths.add(path);
+            }
             else if (/^https?:/i.test(target))
                 outbound++;
         }
@@ -46,10 +52,10 @@ export function maintenanceQueues(pages, o) {
                 linkedIds.add(id);
     }
     const item = (p, detail) => ({ title: p.title, href: o.href(p), tagPath: p.tagPath, detail });
-    const facts = (p) => (p.metadata && typeof p.metadata === 'object' ? p.metadata : {});
+    // 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 => { const v = facts(p)[k.key]; return typeof v !== 'string' || !v.trim(); })
+            .filter(k => !metaValue(p, k.key))
             .map(k => k.label.replace(/:$/, ''));
         return missing.length ? [item(p, `missing ${missing.join(', ')}`)] : [];
     });

package/dist/react-server.js

@@ -200,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)

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();

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';
@@ -34,8 +33,14 @@ export function extractBlocks(blocks, containers, basePath = 'root') {
     });
     return out;
 }
+/** A value with every object's keys in one order: jsonb hands a stored block's keys back in its own. */
+const canonical = (v) => Array.isArray(v)
+    ? v.map(canonical)
+    : v && typeof v === 'object'
+        ? Object.fromEntries(Object.keys(v).sort().map(k => [k, canonical(v[k])]))
+        : v;
 /**
- * Which scalar fields differ. Nested block arrays are skipped: they are walked
+ * Which scalar fields differ, whatever order their keys are in. Nested block arrays are skipped: they are walked
  * as their own entries, and comparing them here would report a container as
  * modified every time anything inside it moved.
  */
@@ -58,7 +63,7 @@ function diffAttributes(oldBlock, newBlock, containers) {
             continue;
         const from = oldBlock[key];
         const to = newBlock[key];
-        if (JSON.stringify(from) !== JSON.stringify(to))
+        if (JSON.stringify(canonical(from)) !== JSON.stringify(canonical(to)))
             diffs[key] = { from, to };
     }
     return Object.keys(diffs).length > 0 ? diffs : undefined;
@@ -128,29 +133,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 +165,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) : '';
 };

package/dist/text.js

@@ -19,7 +19,7 @@ export function stripHtml(html) {
         .replace(/<a[^>]+href="([^"]*)"[^>]*>(.*?)<\/a>/gi, ' $2 ($1) ')
         .replace(/<br\s*\/?>/gi, '\n')
         .replace(/<\/(?:p|h[1-6]|li|tr|th|td|div)>/gi, '\n')
-        .replace(/<(?:li)>/gi, '- ')
+        .replace(/<li\b[^>]*>/gi, '- ')
         .replace(/<[^>]+>/g, ''))
         .replace(/\n{3,}/g, '\n\n')
         .trim();

package/dist/tiptap.d.ts

@@ -82,6 +82,11 @@ export interface TabsOptions {
     /** Names a newly added tab. Receives the 1-based position. */
     tabLabel?: (index: number) => string;
 }
+/**
+ * A tab group and its items, which must be registered together — `tabGroup`'s
+ * content expression is `tabItem+`, so registering one without the other leaves
+ * a node type the schema cannot satisfy.
+ */
 export declare function createTabs({ classNames: own, icons: ownIcons, tabLabel, }?: TabsOptions): {
     TabGroup: TiptapNode<any, any>;
     TabItem: TiptapNode<any, any>;

package/dist/tiptap.js

@@ -200,7 +200,8 @@ export function createMapEmbed({ resolveMapUrl }) {
                         .insertContent({ type: 'mapEmbed', attrs: { src: 'about:blank', url } })
                         .run();
                     resolveMapUrl(url).then(resolved => {
-                        if (!resolved)
+                        // The editor may have closed while the redirect was followed.
+                        if (!resolved || ext.editor.isDestroyed)
                             return;
                         // Find the placeholder by its url rather than by a captured
                         // position: the document has been editable throughout the hop.
@@ -282,11 +283,6 @@ export function createCodeBlock({ langs = CODE_LANGS, defaultLang = DEFAULT_LANG
         },
     });
 }
-/**
- * A tab group and its items, which must be registered together — `tabGroup`'s
- * content expression is `tabItem+`, so registering one without the other leaves
- * a node type the schema cannot satisfy.
- */
 /** The classes `base.css` draws the tab editor with, each replaceable. */
 const TABS_CLASSES = {
     editor: 'tabs-editor',
@@ -298,6 +294,11 @@ const TABS_CLASSES = {
     add: 'tab-add',
     content: 'tabs-content',
 };
+/**
+ * A tab group and its items, which must be registered together — `tabGroup`'s
+ * content expression is `tabItem+`, so registering one without the other leaves
+ * a node type the schema cannot satisfy.
+ */
 export function createTabs({ classNames: own = {}, icons: ownIcons = {}, tabLabel = i => `Tab ${i}`, } = {}) {
     const classNames = { ...TABS_CLASSES, ...own };
     const icons = { add: '+', remove: '×', ...ownIcons };
@@ -328,8 +329,11 @@ export function createTabs({ classNames: own = {}, icons: ownIcons = {}, tabLabe
                 return;
             const pos = posOf(index);
             editor.chain().focus().deleteRange({ from: pos, to: pos + tabs[index].nodeSize }).run();
-            if (activeTab >= tabs.length - 1)
-                setActiveTab(Math.max(0, tabs.length - 2));
+            // The open tab stays open: removing one before it moves it down a place.
+            const at = Math.min(activeTab, tabs.length - 1);
+            const next = Math.max(0, index < at ? at - 1 : Math.min(at, tabs.length - 2));
+            if (next !== activeTab)
+                setActiveTab(next);
         };
         const renameTab = (index, title) => {
             const { tr } = editor.state;

package/dist/validation.d.ts

@@ -1,5 +1,5 @@
 /**
- * An href acceptable to persist: http, https, mailto, or a relative path or
+ * An href acceptable to persist: http, https, mailto, tel, or a relative path or
  * fragment. Everything else — `javascript:`, `data:`, `vbscript:`, a
  * protocol-relative `//host` — comes back null.
  *

package/dist/validation.js

@@ -10,7 +10,7 @@
 // block type is a compile error there until it is handled.
 import { LIST_SOURCES } from './blocks.js';
 /**
- * An href acceptable to persist: http, https, mailto, or a relative path or
+ * An href acceptable to persist: http, https, mailto, tel, or a relative path or
  * fragment. Everything else — `javascript:`, `data:`, `vbscript:`, a
  * protocol-relative `//host` — comes back null.
  *
@@ -23,16 +23,20 @@ export function safeLinkHref(raw) {
     if (!raw)
         return null;
     // Strip C0 controls (including tab, newline and CR) and DEL before reading
-    // the scheme, so a newline cannot smuggle one past the match below.
-    const href = raw.replace(/[\u0000-\u0020\u007f]/g, '').trim();
+    // the scheme, so a newline cannot smuggle one past the match below. A space
+    // is not one: inside a URL it is the author's (`/My Photo.jpg`), and at
+    // either end `trim` takes it.
+    const href = raw.replace(/[\u0000-\u001f\u007f]/g, '').trim();
     if (!href)
         return null;
-    if (href.startsWith('//'))
-        return null; // protocol-relative -> external host
+    // Protocol-relative -> external host. A browser reads `\` as `/` here, so
+    // `/\evil.com` is the same link.
+    if (/^[\\/]{2}/.test(href))
+        return null;
     const scheme = href.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
     if (scheme) {
         const s = scheme[1].toLowerCase();
-        if (s !== 'http' && s !== 'https' && s !== 'mailto')
+        if (s !== 'http' && s !== 'https' && s !== 'mailto' && s !== 'tel')
             return null;
     }
     return href;

package/dist/well-known.d.ts

@@ -124,6 +124,8 @@ export interface McpManifestConfig {
     url: string;
     /** Who runs it. Defaults to `name`. */
     provider?: string;
+    /** The MCP endpoint's absolute URL. Defaults to `${url}/api/mcp`. */
+    mcpEndpoint?: string;
     tools: readonly ManifestTool[];
     /** Auth notes, per-tenant endpoints, payment terms — what this origin has that others do not. */
     extra?: Record<string, unknown>;

package/dist/well-known.js

@@ -186,7 +186,7 @@ export function registryAuthHandler(publicKey = process.env.MCP_REGISTRY_PUBLIC_
  * so the manifest cannot advertise a version the server does not speak.
  */
 export function mcpManifest(config) {
-    const { name, registryName, version, description, url, provider, tools, extra } = config;
+    const { name, registryName, version, description, url, provider, mcpEndpoint, tools, extra } = config;
     return {
         schema_version: '1.0',
         name,
@@ -197,7 +197,7 @@ export function mcpManifest(config) {
         provider: { name: provider ?? name, url },
         api: { type: 'openapi', url: `${url}/.well-known/openapi.json` },
         mcp: {
-            endpoint: `${url}/api/mcp`,
+            endpoint: mcpEndpoint ?? `${url}/api/mcp`,
             transport: 'streamable-http',
             protocol: 'JSON-RPC 2.0',
             protocolVersion: MCP_PROTOCOL_VERSION,

package/dist/wiki-tools.d.ts

@@ -34,7 +34,7 @@ export interface WikiToolsOptions<B extends DiffBlock> {
     metadata?: (tagPath: string, metadata: PageMetadata) => Record<string, unknown> | null;
     /** A category's name as the tree lists it. Defaults to the node's `name`. */
     label?: (node: WikiNode) => string;
-    /** The corpus as sections, when the app's llms-full.txt sets their form. Defaults to one per page from the store. */
+    /** The corpus as sections, when the app sets their form. Defaults to one per page from the store. */
     corpus?: (tagPath?: string) => Promise<CorpusSection[]>;
     /** What an empty search says. */
     noMatch?: (query: string, tagPath?: string) => string;

package/dist/wiki-tools.js

@@ -8,9 +8,9 @@
 // lists a page here lists it the way its HTML route does, hidden paths included.
 //
 // What is the app's: where a page lives (`url`), how blocks read as text,
-// what a row adds (`metadata`), and how its corpus reads when it has an
-// llms-full.txt to match. Writes stay with each app, because who may write
-// is the one thing no two of them agree on.
+// what a row adds (`metadata`), and how its corpus reads when it sets its own
+// sections. Writes stay with each app, because who may write is the one thing
+// no two of them agree on.
 import { McpToolError, readArgs, withAdjustments } from './mcp.js';
 import { listEnvelope } from './pagination.js';
 import { CORPUS_BUDGET, sliceCorpus } from './corpus.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.84.0",
+  "version": "0.85.1",
   "description": "The portable half of a wiki: derived taxonomy and facet controls, a version-negotiating MCP transport, markdown twins, block rendering, a rich-text editor engine, conditional-GET plumbing, and the headers and CSP every origin sends.",
   "type": "module",
   "license": "MIT",

package/prisma/wiki.sql

@@ -44,8 +44,6 @@ CREATE INDEX "WikiPage_siteId_tagPath_updatedAt_idx" ON "WikiPage"("siteId", "ta
 -- CreateIndex
 CREATE INDEX "WikiPage_siteId_updatedAt_idx" ON "WikiPage"("siteId", "updatedAt");
 
--- CreateIndex
-
 -- CreateIndex
 CREATE UNIQUE INDEX "WikiPage_siteId_tagPath_slug_key" ON "WikiPage"("siteId", "tagPath", "slug");