wiki-formant 0.47.1 → 0.49.0

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

package/dist/rate-limit.d.ts

@@ -60,6 +60,11 @@ export interface HeaderReader {
 export declare function clientIp(headers: HeaderReader): string;
 /** `prefix:ip` — the key `rateLimit` expects for a per-IP gate. */
 export declare function clientKey(prefix: string, headers: HeaderReader): string;
+/**
+ * `rateLimit` on the caller's address under `prefix`: the per-IP gate a dozen
+ * call sites across four apps wrote out as `rateLimit(clientKey(…), opts)`.
+ */
+export declare function limitClient(prefix: string, headers: HeaderReader, opts: RateLimitOptions): RateLimitResult;
 /** The message a 429 body carries, so every surface refuses in the same words. */
 export declare function retryMessage(retryAfterSec: number): string;
 /**
@@ -87,22 +92,6 @@ export declare function rateLimitedResponse(retryAfterSec: number): Response;
 export declare function rateLimitHeaders(result: RateLimitResult, opts: RateLimitOptions): Record<string, string>;
 /** `rateLimitHeaders` applied to a response you already have. */
 export declare function withRateLimit<T extends Response>(res: T, result: RateLimitResult, opts: RateLimitOptions): T;
-/** Test seam: the bucket map is module state and outlives a single test. */
-export declare function resetRateLimits(): void;
-/**
- * The one MCP rate-limit number, for every surface that states one.
- *
- * `.well-known/mcp.json`, the OpenAPI spec, agents.md, llms.txt and the
- * `initialize` instructions all quote this, so the endpoint enforces exactly
- * what the documents claim. It is a cross-surface contract, which is why it
- * lives here rather than three times over. A second copy is how a number
- * becomes impossible to change safely: nobody can tell a considered difference
- * from a stale one.
- *
- * A surface with a genuine reason to differ passes its own `RateLimitOptions`.
- * What it must not do is restate this one.
- */
-export declare const MCP_RATE_LIMIT_PER_MIN = 60;
 export declare const MCP_RATE_LIMIT_TEXT = "60 requests per minute per IP";
 /** The budget as `mcpResponse` takes it, so a route states it once. */
 export declare const MCP_RATE_LIMIT: RateLimitOptions;

package/dist/rate-limit.js

@@ -108,6 +108,13 @@ export function clientIp(headers) {
 export function clientKey(prefix, headers) {
     return `${prefix}:${clientIp(headers)}`;
 }
+/**
+ * `rateLimit` on the caller's address under `prefix`: the per-IP gate a dozen
+ * call sites across four apps wrote out as `rateLimit(clientKey(…), opts)`.
+ */
+export function limitClient(prefix, headers, opts) {
+    return rateLimit(clientKey(prefix, headers), opts);
+}
 /** The message a 429 body carries, so every surface refuses in the same words. */
 export function retryMessage(retryAfterSec) {
     return `Too many requests. Try again in ${retryAfterSec}s.`;
@@ -157,7 +164,7 @@ export function withRateLimit(res, result, opts) {
         res.headers.set(k, v);
     return res;
 }
-/** Test seam: the bucket map is module state and outlives a single test. */
+/** Test seam: the bucket map is module state and outlives a single test. @internal */
 export function resetRateLimits() {
     buckets.clear();
     blocks.clear();
@@ -175,6 +182,8 @@ export function resetRateLimits() {
  *
  * A surface with a genuine reason to differ passes its own `RateLimitOptions`.
  * What it must not do is restate this one.
+ *
+ * @internal
  */
 export const MCP_RATE_LIMIT_PER_MIN = 60;
 export const MCP_RATE_LIMIT_TEXT = `${MCP_RATE_LIMIT_PER_MIN} requests per minute per IP`;

package/dist/react-server.d.ts

@@ -103,18 +103,6 @@ export interface RelatedPagesProps {
  * the landmark and the list, the other neither.
  */
 export declare function RelatedPages({ pages, heading, href, link: Link, id }: RelatedPagesProps): import("react").JSX.Element | null;
-/**
- * A JSON-LD payload, safe to place inside `<script type="application/ld+json">`.
- *
- * The body has to go in through `dangerouslySetInnerHTML` — React escapes a
- * text child's `<`, which breaks the parser Google reads — and these payloads
- * carry authored strings: page titles, display names, excerpts. An authored
- * `</script>` closes the tag and the rest parses as markup. Re-encoding every
- * `<` as its JSON escape closes that; every JSON parser decodes it back, so the
- * data a crawler reads is unchanged. One of the three wikis did this; the
- * other two, and this package's own breadcrumb trail, did not.
- */
-export declare function jsonLdScript(data: unknown): string;
 /** A `<script type="application/ld+json">` for `data`, escaped by `jsonLdScript`. */
 export declare function JsonLd({ data }: {
     data: unknown;

package/dist/react-server.js

@@ -92,6 +92,8 @@ export function RelatedPages({ pages, heading, href, link: Link = Anchor, id = '
  * `<` as its JSON escape closes that; every JSON parser decodes it back, so the
  * data a crawler reads is unchanged. One of the three wikis did this; the
  * other two, and this package's own breadcrumb trail, did not.
+ *
+ * @internal
  */
 export function jsonLdScript(data) {
     return JSON.stringify(data).replace(/</g, '\\u003c');

package/dist/revisions.d.ts

@@ -69,13 +69,6 @@ export declare function extractBlocks<B>(blocks: readonly B[], containers: (bloc
  * as one removal and one addition.
  */
 export declare function diffBlocks<B extends DiffBlock, L = unknown>(oldBlocks: readonly B[], newBlocks: readonly B[], opts: DiffOptions<B, L>): BlockChange<L>[];
-/**
- * `major` for structure, `minor` for prose, `patch` for a page-level flag.
- *
- * A `modified` change is only ever recorded when `diffAttributes` returned
- * something, so a non-empty change set is always at least a minor bump.
- */
-export declare function classifyChanges(changes: readonly BlockChange<unknown>[], titleChanged: boolean, metaChanged?: boolean): ChangeType;
 export declare function changeSummary(diff: {
     changes: readonly BlockChange<unknown>[];
     titleChanged: boolean;

package/dist/revisions.js

@@ -132,6 +132,8 @@ export function diffBlocks(oldBlocks, newBlocks, opts) {
  *
  * 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)

package/dist/rola.d.ts

@@ -0,0 +1,74 @@
+import { type JWTPayload } from 'jose';
+export interface SignedChallenge {
+    challenge: string;
+    address: string;
+    proof: {
+        publicKey: string;
+        signature: string;
+        curve: 'curve25519' | 'secp256k1';
+    };
+}
+/** What `prisma.challenge` already is, narrowed to the two calls this makes. */
+export interface ChallengeStore {
+    create(args: {
+        data: {
+            challenge: string;
+            expiresAt: Date;
+        };
+    }): Promise<unknown>;
+    deleteMany(args: {
+        where: {
+            challenge?: string;
+            expiresAt: {
+                lt: Date;
+            } | {
+                gt: Date;
+            };
+        };
+    }): Promise<{
+        count: number;
+    }>;
+}
+export interface RolaOptions {
+    expectedOrigin: string;
+    dAppDefinitionAddress: string;
+    networkId: number;
+    applicationName: string;
+    challenges: ChallengeStore;
+    /** Default 300: the wallet round-trip, with room for a slow signer. */
+    challengeTtlSec?: number;
+}
+export type Verification = {
+    isValid: true;
+} | {
+    isValid: false;
+    error: string;
+};
+export interface RolaAuth {
+    generateChallenge(): Promise<{
+        challenge: string;
+        expiresAt: Date;
+    }>;
+    /** Consumes the challenge whatever the outcome, so a signature cannot be retried. */
+    verifySignedChallenge(signed: SignedChallenge): Promise<Verification>;
+}
+export declare function createRola({ challenges, challengeTtlSec, ...identity }: RolaOptions): RolaAuth;
+/**
+ * The signing key for an environment variable's value. Throws on a missing or
+ * short one: a low-entropy HS256 secret is crackable offline from one captured
+ * token, which would let anyone mint a session for any address. Generate one
+ * with `openssl rand -base64 48`.
+ */
+export declare function sessionSecret(value: string | undefined): Uint8Array;
+/** An HS256 token carrying `claims`, issued now, expiring in `ttlSec`, with a unique `jti`. */
+export declare function signSession(claims: JWTPayload, secret: Uint8Array, ttlSec: number): Promise<string>;
+/**
+ * The claims of a token that verifies, or null for a bad signature, an expired
+ * `exp` or any other algorithm. HS256 is pinned, so a token cannot choose how
+ * it is checked.
+ */
+export declare function verifySession<T extends object = JWTPayload>(token: string, secret: Uint8Array): Promise<(T & JWTPayload) | null>;
+/** An `Authorization: Bearer` token, the way an agent presents the cookie's. */
+export declare function bearerToken(headers: {
+    get(name: string): string | null;
+}): string | null;

package/dist/rola.js

@@ -0,0 +1,97 @@
+// rola.ts — Radix On-Ledger Authentication: a single-use challenge, the wallet's
+// proof of it, and the HS256 token a verified address is handed.
+//
+// radix-wiki and caper sign in the same way and keep a session differently:
+// radix-wiki a `Session` row behind a seven-day cookie, caper a stateless token
+// it slides forward on every visit, with a twelve-hour one for agents. What
+// they share is everything up to the token, plus the token's own arithmetic,
+// and that is all this holds. Where the two copies differed it takes the
+// stricter: a challenge is consumed by one conditional delete, so two requests
+// racing with one signature cannot both pass; expired challenges are purged as
+// new ones are made; only an account proof signs in, which both apps already
+// enforced; a secret under 32 characters refuses to start, since HS256 is only
+// as strong as its secret; and verification pins HS256.
+//
+// The challenge table is a port, not an import: a Prisma client is generated
+// per app, and both apps' `prisma.challenge` already satisfies it. `jose` and
+// `@radixdlt/rola` are optional peers, needed only by an app importing this.
+import { SignJWT, jwtVerify } from 'jose';
+import { Rola } from '@radixdlt/rola';
+const hex = (bytes) => Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+export function createRola({ challenges, challengeTtlSec = 300, ...identity }) {
+    const rola = Rola(identity);
+    return {
+        async generateChallenge() {
+            const challenge = hex(crypto.getRandomValues(new Uint8Array(32)));
+            const expiresAt = new Date(Date.now() + challengeTtlSec * 1000);
+            await challenges.deleteMany({ where: { expiresAt: { lt: new Date() } } });
+            await challenges.create({ data: { challenge, expiresAt } });
+            return { challenge, expiresAt };
+        },
+        async verifySignedChallenge(signed) {
+            try {
+                const { count } = await challenges.deleteMany({
+                    where: { challenge: signed.challenge, expiresAt: { gt: new Date() } },
+                });
+                if (count !== 1) {
+                    console.error('ROLA: challenge invalid or expired', `${signed.challenge.slice(0, 16)}...`);
+                    return { isValid: false, error: 'Invalid or expired challenge' };
+                }
+                // A persona proof names no account, and the session belongs to the
+                // address the proof verified, never to one a request body names.
+                if (!signed.address.startsWith('account_')) {
+                    return { isValid: false, error: 'Sign in with an account proof' };
+                }
+                const result = await rola.verifySignedChallenge({ ...signed, type: 'account' });
+                if (result.isErr()) {
+                    console.error('ROLA: verification failed', result.error.reason, result.error);
+                    return { isValid: false, error: result.error.reason };
+                }
+                return { isValid: true };
+            }
+            catch (error) {
+                console.error('ROLA verification error:', error);
+                return { isValid: false, error: 'Verification failed' };
+            }
+        },
+    };
+}
+/**
+ * The signing key for an environment variable's value. Throws on a missing or
+ * short one: a low-entropy HS256 secret is crackable offline from one captured
+ * token, which would let anyone mint a session for any address. Generate one
+ * with `openssl rand -base64 48`.
+ */
+export function sessionSecret(value) {
+    if (!value || value.length < 32) {
+        throw new Error('The session secret must be at least 32 characters of high-entropy randomness');
+    }
+    return new TextEncoder().encode(value);
+}
+/** An HS256 token carrying `claims`, issued now, expiring in `ttlSec`, with a unique `jti`. */
+export function signSession(claims, secret, ttlSec) {
+    return new SignJWT(claims)
+        .setProtectedHeader({ alg: 'HS256' })
+        .setIssuedAt()
+        .setExpirationTime(`${ttlSec}s`)
+        .setJti(crypto.randomUUID())
+        .sign(secret);
+}
+/**
+ * The claims of a token that verifies, or null for a bad signature, an expired
+ * `exp` or any other algorithm. HS256 is pinned, so a token cannot choose how
+ * it is checked.
+ */
+export async function verifySession(token, secret) {
+    try {
+        const { payload } = await jwtVerify(token, secret, { algorithms: ['HS256'] });
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+/** An `Authorization: Bearer` token, the way an agent presents the cookie's. */
+export function bearerToken(headers) {
+    return headers.get('authorization')?.match(/^Bearer\s+(.+)$/i)?.[1] ?? null;
+}

package/dist/search.d.ts

@@ -20,18 +20,6 @@
  *                when the query aliases its table.
  */
 export declare function proseSql(content?: string): string;
-/**
- * The `regexp_replace` pattern inside {@link proseSql}, as it must appear in
- * SQL. Written for a single-quoted SQL string literal, so a backslash that
- * Postgres' regex engine should see as an escape is doubled here.
- */
-export declare const PROSE_PATTERN = "<[^>]*>|&nbsp;|\\\\[nrt\"\\\\/]|\", \"|\\[\"|\"\\]";
-/**
- * The generated column behind the full-text tier: title at weight A, prose at
- * weight B, so a title hit outranks a body hit inside tier 3 as well as across
- * tiers.
- */
-export declare function searchTsvSql(content?: string, title?: string): string;
 /**
  * The statements that (re)build a table's `search_tsv` column and its GIN index.
  * Run `column` inside one transaction: DROP then ADD, so no reader ever sees

package/dist/search.js

@@ -49,12 +49,16 @@ export function proseSql(content = 'content') {
  * The `regexp_replace` pattern inside {@link proseSql}, as it must appear in
  * SQL. Written for a single-quoted SQL string literal, so a backslash that
  * Postgres' regex engine should see as an escape is doubled here.
+ *
+ * @internal
  */
 export const PROSE_PATTERN = '<[^>]*>|&nbsp;|\\\\[nrt"\\\\/]|", "|\\["|"\\]';
 /**
  * The generated column behind the full-text tier: title at weight A, prose at
  * weight B, so a title hit outranks a body hit inside tier 3 as well as across
  * tiers.
+ *
+ * @internal
  */
 export function searchTsvSql(content = 'content', title = 'title') {
     return `setweight(to_tsvector('english', coalesce(${title},'')), 'A') || ` +

package/dist/sidebar.d.ts

@@ -20,22 +20,6 @@ export declare function resolveSidebarOpen({ chosen, current, stored, isMobile,
 }): boolean;
 /** The attribute the boot script and the hook both write to `<html>`. */
 export declare const SIDEBAR_ATTRIBUTE = "data-sidebar";
-/**
- * The custom property a consumer's stylesheet sets inside its own rail media
- * query — `1` where the rail stops being a column beside the article, `0`
- * elsewhere.
- *
- * The rail's breakpoint is necessarily known twice: this hook needs it in JS
- * (to close the rail on navigate, and to default a first-ever visit), and the
- * stylesheet needs it in CSS (to lay the rail out, before any script runs and
- * whether or not one ever does). A media query cannot read a JS constant and a
- * JS constant cannot read a media query, so the two numbers cannot be merged —
- * but they can be made unable to disagree QUIETLY, which is the actual hazard.
- *
- * All three wikis matched by hand and all three happened to be right; nothing
- * said so. Declaring this property is what opts a stylesheet into the check.
- */
-export declare const RAIL_FLOATING_PROPERTY = "--rail-floating";
 /**
  * What the stylesheet currently says about the rail: `true` inside the repo's
  * rail media query, `false` outside it, `null` when the property is not

package/dist/sidebar.js

@@ -35,6 +35,8 @@ export const SIDEBAR_ATTRIBUTE = 'data-sidebar';
  *
  * All three wikis matched by hand and all three happened to be right; nothing
  * said so. Declaring this property is what opts a stylesheet into the check.
+ *
+ * @internal
  */
 export const RAIL_FLOATING_PROPERTY = '--rail-floating';
 /**

package/dist/stats.d.ts

@@ -9,10 +9,6 @@ export interface StatsProps {
     /** The windows offered as `?days=` links on the same page. */
     ranges?: readonly number[];
 }
-/** The windows the stats page offers, in days; `Infinity` is all time. */
-export declare const STATS_RANGES: readonly [1, 7, 30, 90, 365, number];
-/** A `?days=` value as one of `ranges`, else `fallback`. */
-export declare const statsDays: (param: unknown, ranges?: readonly number[], fallback?: number) => number;
 /**
  * A stats page's query as the window and the filter, both ready for `digest`
  * and `Stats`: `const q = statsQuery(await searchParams)`. A repeated or empty

package/dist/stats.js

@@ -2,12 +2,12 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { STATS_FILTERS } from './analytics.js';
 import { StatsFigures } from './stats-figures.js';
 /** The windows the stats page offers, in days; `Infinity` is all time. */
-export const STATS_RANGES = [1, 7, 30, 90, 365, Infinity];
+const STATS_RANGES = [1, 7, 30, 90, 365, Infinity];
 /** A window as its `?days=` value. */
 const daysParam = (n) => (Number.isFinite(n) ? String(n) : 'all');
 /** A window as `TimeChart` names its ranges, since its buttons are where the windows sit. */
 const windowLabel = (n) => (n === 1 ? '24H' : n === 365 ? '1Y' : Number.isFinite(n) ? `${n}D` : 'All');
-/** A `?days=` value as one of `ranges`, else `fallback`. */
+/** A `?days=` value as one of `ranges`, else `fallback`. @internal */
 export const statsDays = (param, ranges = STATS_RANGES, fallback = 30) => ranges.find(n => daysParam(n) === param) ?? fallback;
 /**
  * A stats page's query as the window and the filter, both ready for `digest`

package/dist/taxonomy.d.ts

@@ -118,10 +118,6 @@ export interface TaxonomyConfig {
 export declare function hrefBuilder(prefix?: string): (tagPath: string, state: CategoryState) => string;
 /** Categories mounted at the root. */
 export declare const defaultHref: (tagPath: string, state: CategoryState) => string;
-/** Bucket for titles that don't start with a letter (numerals, `$CAPER`). */
-export declare function firstLetter(title: string): string;
-/** Adding a filter already active removes it, so every chip is its own off-switch. */
-export declare function toggleFilter(filters: FacetFilters, key: string, value: string): FacetFilters;
 export interface Taxonomy {
     /** The select-typed keys a tag path declares — its facetable axes. */
     facetKeys: (tagPath: string) => MetadataKeyDefinition[];

package/dist/taxonomy.js

@@ -38,12 +38,12 @@ export function hrefBuilder(prefix = '') {
 export const defaultHref = hrefBuilder();
 const DEFAULT_ALPHA_INDEX_MIN_PAGES = 40;
 const metaValue = (page, key) => (page.metadata?.[key] ?? '').trim();
-/** Bucket for titles that don't start with a letter (numerals, `$CAPER`). */
+/** Bucket for titles that don't start with a letter (numerals, `$CAPER`). @internal */
 export function firstLetter(title) {
     const ch = title.trim()[0]?.toUpperCase() ?? '';
     return ch >= 'A' && ch <= 'Z' ? ch : '#';
 }
-/** Adding a filter already active removes it, so every chip is its own off-switch. */
+/** Adding a filter already active removes it, so every chip is its own off-switch. @internal */
 export function toggleFilter(filters, key, value) {
     const next = { ...filters };
     if (next[key] === value)

package/dist/text.d.ts

@@ -1,4 +1,3 @@
-import type { CodeTab, LinkGridGroup, ReferenceItem, StatItem } from './blocks.js';
 /**
  * HTML to readable text. Links keep their href in parentheses so a model can
  * still follow a citation; block-level tags become newlines; list items get a
@@ -6,6 +5,22 @@ import type { CodeTab, LinkGridGroup, ReferenceItem, StatItem } from './blocks.j
  * prose cannot become a tag the strip has already run past.
  */
 export declare function stripHtml(html: string): string;
+/**
+ * HTML as one plain line: tags become spaces, entities are decoded, and the
+ * space a tag left before punctuation is closed up again, or prose that wrapped
+ * a link around the word before a comma reads "the Radix network ." Unlike
+ * `stripHtml`, links keep no href: this is for a description, not evidence.
+ */
+export declare function plainText(html: string): string;
+/**
+ * How a page opens: the first top-level `content` block that has prose once
+ * its headings are out, as plain text. Wiki pages open with an infobox far more
+ * often than not, so the first characters of the whole page are a flattened
+ * metadata table, which is what two wikis' descriptions said until both
+ * switched to this rule. `''` when no block has prose; a wiki with other
+ * prose-bearing types falls back to its own extractor.
+ */
+export declare function openingText(blocks: unknown): string;
 /** The six maintenance-banner variants every wiki here renders. */
 export type BannerVariant = 'stub' | 'unsourced' | 'outdated' | 'promotional' | 'cleanup' | 'coi';
 /**
@@ -29,27 +44,6 @@ export declare const BANNER_VARIANTS: ReadonlyArray<{
 }>;
 /** A stored variant this package knows, or `cleanup` for one it does not. */
 export declare function bannerVariant(variant: string): BannerVariant;
-/** A maintenance notice, inline: `[Notice: Needs citations] …`. */
-export declare function bannerToText(label: string, text?: string | null): string;
-/** Each tab under its label, tags stripped — highlighted markup is noise here. */
-export declare function codeTabsToText(tabs: readonly CodeTab[]): string;
-/** Metric cards, one per line: `99% Uptime`. */
-export declare function statsToText(items: readonly StatItem[]): string;
-/**
- * Each group's heading over its links, hrefs in parentheses the way
- * `stripHtml` keeps them.
- *
- * Two of the three wikis extracted nothing from a link grid, or from stats or
- * page lists, so a hub page read to an agent as far emptier than it is. The
- * third had its own three bodies. These are those bodies.
- */
-export declare function linkGridToText(groups: readonly LinkGridGroup[], intro?: string | null): string;
-/** A resolved page list: one title per line. */
-export declare function pageListToText(pages: readonly {
-    title: string;
-}[]): string;
-/** A numbered reference list, or `''` when there are none. */
-export declare function referencesToText(items: readonly ReferenceItem[]): string;
 /**
  * The passage that matched `query`, not the opening of the page.
  *