wiki-formant 0.48.0 → 0.50.0

package/dist/headers.js

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

package/dist/headings.d.ts

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

package/dist/headings.js

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

package/dist/history.d.ts

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

package/dist/history.js

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

package/dist/http.d.ts

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

package/dist/http.js

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

package/dist/license.d.ts

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

package/dist/license.js

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

package/dist/link-check.d.ts

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

package/dist/link-check.js

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

package/dist/links.d.ts

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

package/dist/links.js

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

package/dist/maintenance.d.ts

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

package/dist/maintenance.js

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

package/dist/maps.d.ts

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

package/dist/maps.js

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

package/dist/markdown.d.ts

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

package/dist/markdown.js

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

package/dist/mcp.d.ts

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

package/dist/mcp.js

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

package/dist/metadata.d.ts

@@ -152,17 +152,6 @@ export declare function faqPageLd(pairs: readonly QaPair[], url: string): LdNode
  * which is the number that matters to whoever writes the title.
  */
 export declare const TITLE_BUDGET = 60;
-/**
- * Past this, a title is not merely trimmed but cut into.
- *
- * Between the budget and this limit a title loses its tail, which is often the
- * site name and no loss at all. Past it, the words carrying what the page is
- * about are going too: the radix.wiki ideas board spent its first sixteen
- * characters on a working group and reached 93, and the symptom pages on
- * acuiq.com reached 88 before naming the symptom. That is the line worth
- * failing a build over; the band below it is worth reporting and no more.
- */
-export declare const TITLE_LIMIT = 70;
 /**
  * The document `<title>` for a page: its short form where the page carries one,
  * else its own title.
@@ -196,6 +185,20 @@ export declare function fittingTitle(variants: readonly string[], opts?: {
     suffix?: string;
     limit?: number;
 }): string;
+/** Characters a search result shows of a meta description before it cuts. */
+export declare const DESCRIPTION_LIMIT = 160;
+/**
+ * A meta description from any prose: HTML, markdown or plain. Tags, entities,
+ * link targets and bare URLs go; what is left is fitted to `limit` as whole
+ * sentences where they fill at least half of it, else cut at a word and marked
+ * with an ellipsis. Never longer than `limit`.
+ *
+ * Each of the four sites had its own: one clamped at 150 mid-word, one sliced
+ * at 160 with no mark, one fitted sentences, and one kept whatever sentences
+ * fitted however few. Pass a page's own excerpt where it has one and its
+ * opening (`openingText`) where it does not: `describe(excerpt || openingText(blocks))`.
+ */
+export declare function describe(text: string | null | undefined, limit?: number): string;
 /**
  * `pageMetadata` bound to a site's name, locale and handle, the three fields
  * Next drops from every page that sets its own card. Two wikis wrapped it to

package/dist/metadata.js

@@ -19,6 +19,7 @@
 // with no image while their og:image named a card, one listed citations, one
 // collection page had no ItemList at all.
 import { decodeEntities } from './markdown.js';
+import { plainText } from './text.js';
 export function pageMetadata(o) {
     const { title, description, url, type = 'website', image, imageSize = { width: 1200, height: 630 }, siteName, locale, handle, markdownTwin, article } = o;
     const images = image ? [{ url: image, ...imageSize, alt: o.imageAlt ?? title }] : undefined;
@@ -175,6 +176,8 @@ export const TITLE_BUDGET = 60;
  * characters on a working group and reached 93, and the symptom pages on
  * acuiq.com reached 88 before naming the symptom. That is the line worth
  * failing a build over; the band below it is worth reporting and no more.
+ *
+ * @internal
  */
 export const TITLE_LIMIT = 70;
 /**
@@ -216,6 +219,36 @@ export function fittingTitle(variants, opts = {}) {
         return '';
     return usable.find(v => v.length + suffix.length <= limit) ?? usable[usable.length - 1];
 }
+/** Characters a search result shows of a meta description before it cuts. */
+export const DESCRIPTION_LIMIT = 160;
+/**
+ * A meta description from any prose: HTML, markdown or plain. Tags, entities,
+ * link targets and bare URLs go; what is left is fitted to `limit` as whole
+ * sentences where they fill at least half of it, else cut at a word and marked
+ * with an ellipsis. Never longer than `limit`.
+ *
+ * Each of the four sites had its own: one clamped at 150 mid-word, one sliced
+ * at 160 with no mark, one fitted sentences, and one kept whatever sentences
+ * fitted however few. Pass a page's own excerpt where it has one and its
+ * opening (`openingText`) where it does not: `describe(excerpt || openingText(blocks))`.
+ */
+export function describe(text, limit = DESCRIPTION_LIMIT) {
+    const t = plainText(text ?? '')
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/\((?:https?:\/\/|mailto:|\/|#)[^)\s]*\)/g, '')
+        .replace(/https?:\/\/\S+/g, '')
+        .replace(/\(\s*\)/g, '')
+        .replace(/\s+([,.;:!?])/g, '$1')
+        .replace(/\s{2,}/g, ' ')
+        .trim();
+    if (t.length <= limit)
+        return t;
+    const sentences = t.slice(0, limit + 1).match(/^.*[.!?](?=\s)/)?.[0];
+    if (sentences && sentences.length >= limit / 2)
+        return sentences;
+    const cut = t.lastIndexOf(' ', limit - 1);
+    return `${t.slice(0, cut > 0 ? cut : limit - 1).replace(/[\s,;:–—-]+$/, '')}…`;
+}
 // ---- the site's own identity ----------------------------------------------------
 /**
  * `pageMetadata` bound to a site's name, locale and handle, the three fields

package/dist/pagination.d.ts

@@ -42,11 +42,6 @@ export declare function listEnvelope<T>(pages: T[], total: number, page: number,
     note?: string;
     pages: T[];
 };
-/** The `skip`/`take` an ORM wants, from the same clamped pair. */
-export declare function toOffset({ page, pageSize }: Pagination): {
-    skip: number;
-    take: number;
-};
 /**
  * The entries either side of the current one in an already-ordered list.
  *

package/dist/pagination.js

@@ -52,10 +52,6 @@ export function listEnvelope(pages, total, page, pageSize, emptyNote) {
         pages,
     };
 }
-/** The `skip`/`take` an ORM wants, from the same clamped pair. */
-export function toOffset({ page, pageSize }) {
-    return { skip: (page - 1) * pageSize, take: pageSize };
-}
 /**
  * The entries either side of the current one in an already-ordered list.
  *

package/dist/passkey.js

@@ -10,21 +10,8 @@
 // not open the deployed site, and one saved on the site does not open localhost.
 //
 // Like analytics, the package owns the SQL and the app owns the connection. The
-// app declares the two tables in its own schema:
-//
-//   model Passkey {
-//     id         String   @id // the credential id, base64url
-//     publicKey  String       // base64url
-//     counter    Int
-//     transports String[]
-//     createdAt  DateTime @default(now()) @db.Timestamptz(3)
-//   }
-//
-//   model PasskeyToken {
-//     hash      String   @id // sha-256 of the token, base64url
-//     kind      String       // session | invite | challenge
-//     expiresAt DateTime @db.Timestamptz(3)
-//   }
+// two tables are Prisma models shipped in `prisma/passkey.prisma`, which the
+// `prisma-models` bin copies into the app's schema folder.
 //
 // Every token is stored as its hash, so a read of the table opens nothing. A
 // challenge is spent the moment a response quotes it, and an invite the moment