wiki-formant 0.97.1 → 0.98.1

package/dist/base.css

@@ -276,6 +276,7 @@ tbody > tr:nth-child(even) > :is(th, td):not(.chart *) { background-image: linea
 .see-also-detail { font-size: var(--ui-small); color: var(--ui-muted); }
 
 .link-preview-card { position: fixed; z-index: 50; width: 20rem; max-width: calc(100vw - 1rem); overflow: hidden; background: var(--ui-surface); border: 1px solid var(--ui-border); border-radius: var(--ui-radius); box-shadow: var(--ui-shadow, 0 8px 24px -4px rgb(0 0 0 / 0.25)); }
+.link-preview-banner { display: block; width: 100%; height: 7rem; object-fit: cover; }
 .link-preview-body { display: flex; flex-direction: column; gap: 0.25rem; padding: 0.75rem; }
 .link-preview-title { font-weight: 600; }
 .link-preview-excerpt { display: -webkit-box; margin: 0; overflow: hidden; font-size: var(--ui-small); color: var(--ui-muted); -webkit-line-clamp: 4; -webkit-box-orient: vertical; }

package/dist/category.d.ts

@@ -33,8 +33,9 @@ export type CategoryQuery = Record<string, string | string[] | undefined>;
 /**
  * A category's pages narrowed by its facets and an A–Z letter, sorted A–Z or
  * newest first (by a `date` key where the category declares one), and a card
- * per visible child. A set small enough to need no index offers no sort: it is
- * A–Z.
+ * per visible child. The order is the category's own until the query asks for
+ * the other, whatever the set's size: a blog of thirty posts is still newest
+ * first, though it is too short for an A–Z index.
  */
 export declare function categoryView<P extends FacetablePage & {
     tagPath: string;

package/dist/category.js

@@ -2,7 +2,7 @@
 // taxonomy and the store.
 //
 // radix-wiki assembled this inside its route and miow copied it line for line:
-// the count, a sort that only shows once the set needs an A–Z index, the facets
+// the count, a sort toggle for any set with two pages to order, the facets
 // its `select` keys give, a letter that exists, and a card per section listing
 // what it holds. acuiq2 kept a subset that had drifted (no sort, no cards). The
 // view is the app's; the arithmetic is here.
@@ -11,21 +11,20 @@ const one = (v) => (Array.isArray(v) ? v[0] : v);
 /**
  * A category's pages narrowed by its facets and an A–Z letter, sorted A–Z or
  * newest first (by a `date` key where the category declares one), and a card
- * per visible child. A set small enough to need no index offers no sort: it is
- * A–Z.
+ * per visible child. The order is the category's own until the query asks for
+ * the other, whatever the set's size: a blog of thirty posts is still newest
+ * first, though it is too short for an A–Z index.
  */
 export async function categoryView({ tree, taxonomy, pages: reader }, tagPath, query, { href = wikiPath, cardPages = 6, limit = 2000 } = {}) {
     const resolved = tree.resolve(tagPath);
     const order = (path, sort) => sort === 'recent' && tree.metadataKeys(path).some(k => k.key === 'date' && k.type === 'date') ? 'date' : sort;
     const fallback = (path) => (tree.resolve(path).sort === 'title' ? 'title' : 'recent');
     const asked = one(query.sort);
-    const requested = asked === 'title' || asked === 'recent' ? asked : fallback(tagPath);
-    const fetched = await reader.list(tagPath, { sort: order(tagPath, requested), limit });
-    const sort = taxonomy.needsAlphaIndex(fetched.length) ? requested : 'title';
-    const all = sort === requested ? fetched : await reader.list(tagPath, { sort: order(tagPath, sort), limit });
+    const sort = asked === 'title' || asked === 'recent' ? asked : fallback(tagPath);
+    const all = await reader.list(tagPath, { sort: order(tagPath, sort), limit });
     const filters = taxonomy.facetFilters(tagPath, query);
     const letter = taxonomy.resolveLetter(all, filters, one(query.letter)?.toUpperCase());
-    const sortable = taxonomy.needsAlphaIndex(all.length);
+    const sortable = all.length > 1;
     // A link carries the sort only when it is not the category's own, so the bare
     // category and its default are one address, not two.
     const state = { sort: sortable && sort !== fallback(tagPath) ? sort : undefined, filters, letter };

package/dist/conformance.d.ts

@@ -66,6 +66,7 @@ export interface TesterOptions {
 export interface Tester {
     base: string;
     endpoint: string;
+    clientName: string;
     /** One JSON-RPC call. Waits out a 429 as `Retry-After` asks, up to four tries. */
     rpc(method: string, params?: unknown): Promise<Rpc>;
     /** `tools/call` shorthand. */
@@ -266,3 +267,65 @@ export declare function rolaOriginCheck(t: Tester, opts?: {
     endpoint?: string;
     tool?: string;
 }): Promise<void>;
+export interface StandardSuiteConfig {
+    /** `server.json`'s version, which `initialize` and every descriptor must state. */
+    version: string;
+    /** The capability keys `initialize` must declare. Default `['tools']`. */
+    capabilities?: readonly string[];
+    /** Every path the OpenAPI document is served at. */
+    openapi?: readonly string[];
+    /** The tools that write, which must not be marked read-only. */
+    writes?: readonly string[];
+    /** `manifestParity`'s options. */
+    manifest?: Parameters<typeof manifestParity>[1];
+    /** The calls `payloadBudget` weighs beyond the no-argument ones it finds itself; `[]` for those alone. None skips it. */
+    budget?: Parameters<typeof payloadBudget>[1];
+    /** Surfaces an agent recrawls, for `conditionalGetChecks`. None skips it. */
+    conditionalGet?: readonly string[];
+    /** JSON descriptors, for `descriptorChecks`. Default `S10_DESCRIPTORS`. */
+    descriptors?: readonly string[];
+    /** Paths the `User-agent: *` group must reach, for `robotsChecks`. None skips it. */
+    robots?: readonly string[];
+}
+/**
+ * The suites every surface's `scripts/_mcp-test.ts` runs, in the order they
+ * run them: transport, version coherence, the agent card, annotations, the
+ * manifest, payload budgets, conditional GETs, descriptors and robots. Returns
+ * the `initialize` response for the surface's own assertions.
+ */
+export declare function standardSuite(t: Tester, cfg: StandardSuiteConfig): Promise<Rpc>;
+/** A row as `search_wiki` and `list_pages` return it. */
+export interface WikiReadRow {
+    path: string;
+    tagPath?: string;
+    slug?: string;
+    id?: string;
+    url?: string;
+}
+export interface WikiReadCheckOptions {
+    /** A query with hits on this wiki. */
+    query: string;
+    /** `get_page`'s arguments for a row. Default `{ path }`. */
+    address?: (row: WikiReadRow) => Record<string, unknown>;
+    /** A row's markdown twin, for `twinParity`. None skips it. */
+    twin?: (row: WikiReadRow) => string;
+    /** The `maxChars` the corpus slice is asked for, at least `CORPUS_BUDGET.min`. Default 20,000. */
+    corpusChars?: number;
+    endpoint?: string;
+    label?: string;
+}
+/**
+ * The `wiki-formant/wiki-tools` read tools answer as an agent expects: the
+ * categories, a search and the page it finds, a listing, recent changes, a
+ * corpus preflight and a page-aligned slice that resumes, and the teaching
+ * answers to no hits, a missing argument, an unknown tool and a missing page.
+ * Returns the search rows and the page read, for the surface's own checks.
+ */
+export declare function wikiReadChecks(t: Tester, opts: WikiReadCheckOptions): Promise<{
+    rows: WikiReadRow[];
+    first: WikiReadRow | undefined;
+    page: {
+        title?: string;
+        content?: string;
+    } | undefined;
+}>;

package/dist/conformance.js

@@ -65,6 +65,7 @@ export function createTester(opts) {
     return {
         base,
         endpoint,
+        clientName: opts.clientName,
         rpc,
         call: (name, args = {}) => rpc('tools/call', { name, arguments: args }),
         rpcAt,
@@ -625,3 +626,76 @@ export async function rolaOriginCheck(t, opts = {}) {
     const message = answer?.sign?.message ?? '';
     t.check('ROLA recipe names this origin', message.includes(`"${origin}"`), `expects "${origin}" in: …${message.slice(-90)}`);
 }
+/**
+ * The suites every surface's `scripts/_mcp-test.ts` runs, in the order they
+ * run them: transport, version coherence, the agent card, annotations, the
+ * manifest, payload budgets, conditional GETs, descriptors and robots. Returns
+ * the `initialize` response for the surface's own assertions.
+ */
+export async function standardSuite(t, cfg) {
+    const init = await transportChecks(t, t.clientName, cfg.capabilities);
+    await versionCoherence(t, cfg.version, standardVersionSources(t, cfg.openapi), init.result?.serverInfo?.version);
+    await agentCardParity(t);
+    await annotationChecks(t, { writes: cfg.writes });
+    await manifestParity(t, cfg.manifest);
+    if (cfg.budget)
+        await payloadBudget(t, cfg.budget);
+    if (cfg.conditionalGet)
+        await conditionalGetChecks(t, cfg.conditionalGet);
+    await descriptorChecks(t, cfg.descriptors);
+    if (cfg.robots)
+        await robotsChecks(t, cfg.robots);
+    return init;
+}
+/**
+ * The `wiki-formant/wiki-tools` read tools answer as an agent expects: the
+ * categories, a search and the page it finds, a listing, recent changes, a
+ * corpus preflight and a page-aligned slice that resumes, and the teaching
+ * answers to no hits, a missing argument, an unknown tool and a missing page.
+ * Returns the search rows and the page read, for the surface's own checks.
+ */
+export async function wikiReadChecks(t, opts) {
+    const endpoint = opts.endpoint ?? t.endpoint;
+    const label = (s) => (opts.label ? `[${opts.label}] ${s}` : s);
+    const address = opts.address ?? (row => ({ path: row.path }));
+    const call = (name, args) => t.callAt(endpoint, name, args);
+    const read = async (name, args) => t.payload(await call(name, args));
+    const text = (r) => r.result?.content?.[0]?.text ?? '';
+    const cats = await read('get_categories');
+    t.check(label('get_categories'), (cats?.categories?.length ?? 0) > 0, `${cats?.categories?.length ?? 0} categories`);
+    const search = await read('search_wiki', { query: opts.query, pageSize: 5 });
+    const rows = search?.pages ?? [];
+    const first = rows[0];
+    t.check(label('search_wiki'), (search?.total ?? 0) > 0 && !!first?.path, `${search?.total ?? 0} hits for "${opts.query}", first="${first?.path}"`);
+    const page = first ? await read('get_page', address(first)) : undefined;
+    t.check(label('get_page'), !!page?.title, `"${page?.title}" ${page?.content?.length ?? 0} chars`);
+    if (first && opts.twin)
+        await twinParity(t, label('get_page is the .md twin'), opts.twin(first), page?.content ?? '');
+    const listed = await read('list_pages', { pageSize: 5 });
+    t.check(label('list_pages'), (listed?.pages?.length ?? 0) > 0, `${listed?.pages?.length ?? 0} of ${listed?.total ?? 0}`);
+    const recent = await read('get_recent_changes', { days: 30, limit: 5 });
+    t.check(label('get_recent_changes'), Array.isArray(recent?.pages), `${recent?.pages?.length ?? 0} pages changed in 30d`);
+    // A corpus under the budget comes back whole; one over it, cut on a page
+    // boundary with somewhere to resume from. The 1,000 is the heading and the
+    // separators the document carries beside its pages.
+    const maxChars = opts.corpusChars ?? 20_000;
+    const size = await read('get_full_corpus', { sizeOnly: true });
+    const characters = size?.characters ?? 0;
+    t.check(label('get_full_corpus(sizeOnly)'), characters > 0 && (size?.totalPages ?? 0) > 0, `${size?.totalPages} pages, ${characters.toLocaleString()} chars`);
+    const slice = await read('get_full_corpus', { maxChars });
+    const over = characters > maxChars;
+    t.check(label('get_full_corpus(bounded)'), (slice?.document?.length ?? Infinity) <= maxChars + 1_000 && slice?.truncated === over, `${(slice?.document?.length ?? 0).toLocaleString()} chars for maxChars=${maxChars.toLocaleString()}, ${slice?.includedPages} pages, truncated=${slice?.truncated}, nextSkip=${slice?.nextSkip}`);
+    if (typeof slice?.nextSkip === 'number') {
+        const resumed = await read('get_full_corpus', { maxChars, skip: slice.nextSkip });
+        t.check(label('get_full_corpus(resumes)'), resumed?.skip === slice.nextSkip && resumed?.document !== slice.document, `skip=${resumed?.skip} returns a different slice`);
+    }
+    const none = await read('search_wiki', { query: 'zzzqqqnotathing' });
+    t.check(label('no hits teach'), none?.total === 0 && !!none?.note, none?.note?.slice(0, 80) ?? 'no note on an empty result');
+    const missing = await call('search_wiki', {});
+    t.check(label('missing argument'), !!missing.result?.isError && text(missing).includes('"query"') && text(missing).includes('Expected schema'), text(missing).split('\n')[0] ?? '');
+    const unknown = await call('no_such_tool', {});
+    t.check(label('unknown tool'), unknown.error?.code === -32602 && (unknown.error.message ?? '').includes('search_wiki'), `${unknown.error?.code}: ${(unknown.error?.message ?? '').slice(0, 80)}`);
+    const miss = await call('get_page', address({ path: 'definitely/not/a-page', tagPath: 'definitely/not', slug: 'a-page' }));
+    t.check(label('get_page(404) teaches'), !!miss.result?.isError && text(miss).includes('didYouMean'), text(miss).slice(0, 80));
+    return { rows, first, page };
+}

package/dist/corpus.d.ts

@@ -7,9 +7,13 @@ export interface CorpusSection {
     /** Heading, URL, date and body, exactly as the document will carry them. */
     section: string;
 }
-/** `maxChars` bounds: the default, the floor and the ceiling. Quote them in the tool's schema. */
+/**
+ * `maxChars` bounds: the default, the floor and the ceiling. Quote them in the
+ * tool's schema. The default slice, with its JSON around it, stays inside
+ * `payloadBudget`'s 120,000, since a call with no arguments is weighed there.
+ */
 export declare const CORPUS_BUDGET: {
-    readonly default: 200000;
+    readonly default: 100000;
     readonly min: 1000;
     readonly max: 1000000;
 };

package/dist/corpus.js

@@ -11,8 +11,12 @@
 //
 // The corpus itself — which rows, in what order, how a page becomes a section —
 // stays with each wiki. This is the arithmetic over the sections it hands in.
-/** `maxChars` bounds: the default, the floor and the ceiling. Quote them in the tool's schema. */
-export const CORPUS_BUDGET = { default: 200_000, min: 1_000, max: 1_000_000 };
+/**
+ * `maxChars` bounds: the default, the floor and the ceiling. Quote them in the
+ * tool's schema. The default slice, with its JSON around it, stays inside
+ * `payloadBudget`'s 120,000, since a call with no arguments is weighed there.
+ */
+export const CORPUS_BUDGET = { default: 100_000, min: 1_000, max: 1_000_000 };
 const CLIP_MARKER = '\n\n[…page clipped at maxChars…]';
 /**
  * A preflight (`sizeOnly`) or one page-aligned slice of `sections`.

package/dist/editor.js

@@ -72,8 +72,8 @@ function cleanPastedHtml(html) {
  * stored HTML, so a page edited once kept them for good. Nofollow on a site's
  * own links throws away its link equity, and a new tab for in-site navigation
  * is a bug. Whether a link is external depends on the host it is served from,
- * which the editor cannot know, so the render path decides: `normaliseLinks`
- * from `wiki-formant/links`. Dropping both attributes from the mark also cleans
+ * which the editor cannot know, so the render path decides: `articleHtml`'s
+ * `links` pass in `wiki-formant/headings`. Dropping both attributes from the mark also cleans
  * a legacy link the next time its page is saved.
  *
  * @internal

package/dist/headers.d.ts

@@ -39,7 +39,14 @@ interface WikiNextConfig {
     experimental?: object;
     images?: object;
     headers?: () => Promise<unknown[]> | unknown[];
+    rewrites?: () => Promise<WikiRewrites> | WikiRewrites;
 }
+/** A Next `rewrites()` answer: a bare list (run after the file system) or the three phases. */
+type WikiRewrites = unknown[] | {
+    beforeFiles?: unknown[];
+    afterFiles?: unknown[];
+    fallback?: unknown[];
+};
 /**
  * An app's Next config with the settings every app here wrote out the same way:
  *
@@ -53,9 +60,13 @@ interface WikiNextConfig {
  * - `securityHeaders` on every route, with `csp` enforced in production only:
  *   Next's dev runtime is inline and `eval`. An origin that sets its policy
  *   per request (a nonce) passes none.
+ * - `/openapi.json` rewritten to `/.well-known/openapi.json` ahead of the file
+ *   system, so the spec answers at both paths S10 publishes it at.
  *
- * Anything the app sets wins, and its own `headers()` follow these. Pass
- * `NextConfig` as `T` so the object is typed as Next's own config.
+ * Anything the app sets wins, and its own `headers()` follow these; its
+ * `rewrites()`, in either form, keep their phases with this one first in
+ * `beforeFiles`. Pass `NextConfig` as `T` so the object is typed as Next's own
+ * config.
  */
 export declare function withWikiDefaults<T extends WikiNextConfig>(config: T, { csp }?: {
     csp?: string;

package/dist/headers.js

@@ -88,6 +88,8 @@ export function securityHeaders(csp) {
         { key: 'X-DNS-Prefetch-Control', value: 'on' },
     ];
 }
+/** The OpenAPI document at the bare path an agent guesses beside `/.well-known/openapi.json`. */
+const OPENAPI_REWRITE = { source: '/openapi.json', destination: '/.well-known/openapi.json' };
 /**
  * An app's Next config with the settings every app here wrote out the same way:
  *
@@ -101,9 +103,13 @@ export function securityHeaders(csp) {
  * - `securityHeaders` on every route, with `csp` enforced in production only:
  *   Next's dev runtime is inline and `eval`. An origin that sets its policy
  *   per request (a nonce) passes none.
+ * - `/openapi.json` rewritten to `/.well-known/openapi.json` ahead of the file
+ *   system, so the spec answers at both paths S10 publishes it at.
  *
- * Anything the app sets wins, and its own `headers()` follow these. Pass
- * `NextConfig` as `T` so the object is typed as Next's own config.
+ * Anything the app sets wins, and its own `headers()` follow these; its
+ * `rewrites()`, in either form, keep their phases with this one first in
+ * `beforeFiles`. Pass `NextConfig` as `T` so the object is typed as Next's own
+ * config.
  */
 export function withWikiDefaults(config, { csp } = {}) {
     return {
@@ -117,5 +123,10 @@ export function withWikiDefaults(config, { csp } = {}) {
                 ...((await config.headers?.()) ?? []),
             ];
         },
+        async rewrites() {
+            const own = (await config.rewrites?.()) ?? {};
+            const phases = Array.isArray(own) ? { afterFiles: own } : own;
+            return { ...phases, beforeFiles: [OPENAPI_REWRITE, ...(phases.beforeFiles ?? [])] };
+        },
     };
 }

package/dist/react.d.ts

@@ -216,6 +216,17 @@ export interface LinkPreviewState<T> {
  * three things, and those three are the options above.
  */
 export declare function useLinkPreview<T>({ eligible, fetch, cardClassName, cardWidth, cardHeight, showDelay, hideDelay, margin, }: LinkPreviewOptions<T>): LinkPreviewState<T>;
+/**
+ * The card `useLinkPreview` positions: an optional banner, the title and the
+ * excerpt, in base.css's `link-preview-*` classes. Spread `cardProps` onto it;
+ * a caller that has to move the card (out of a query container) passes its own
+ * `style`.
+ */
+export declare function LinkPreviewCard({ title, excerpt, bannerImage, ...card }: LinkPreviewState<unknown>['cardProps'] & {
+    title: string;
+    excerpt?: string | null;
+    bannerImage?: string | null;
+}): import("react").JSX.Element;
 export type SortDirection = 'asc' | 'desc';
 export interface TableSortState<T, K extends string> {
     sorted: T[];

package/dist/react.js

@@ -520,6 +520,15 @@ export function useLinkPreview({ eligible, fetch, cardClassName = 'link-preview-
         },
     };
 }
+/**
+ * The card `useLinkPreview` positions: an optional banner, the title and the
+ * excerpt, in base.css's `link-preview-*` classes. Spread `cardProps` onto it;
+ * a caller that has to move the card (out of a query container) passes its own
+ * `style`.
+ */
+export function LinkPreviewCard({ title, excerpt, bannerImage, ...card }) {
+    return (_jsxs("div", { className: "link-preview-card", ...card, children: [bannerImage && _jsx("img", { src: bannerImage, alt: "", className: "link-preview-banner", loading: "lazy" }), _jsxs("div", { className: "link-preview-body", children: [_jsx("div", { className: "link-preview-title", children: title }), excerpt && _jsx("p", { className: "link-preview-excerpt", children: excerpt })] })] }));
+}
 /**
  * One active column, direction toggling on re-click, every table the same.
  *

package/dist/rola.d.ts

@@ -1,4 +1,5 @@
 import { type JWTPayload } from 'jose';
+import { type McpTool } from './mcp.js';
 export interface SignedChallenge {
     challenge: string;
     address: string;
@@ -72,3 +73,41 @@ export declare function verifySession<T extends object = JWTPayload>(token: stri
 export declare function bearerToken(headers: {
     get(name: string): string | null;
 }): string | null;
+export interface RolaLoginToolsOptions {
+    /** What a token writes to, as in "Step 1 of writing to the wiki". */
+    site: string;
+    dAppDefinitionAddress: string;
+    /** The origin the verifier checks, which the signed message names. */
+    origin: string;
+    generateChallenge: () => Promise<{
+        challenge: string;
+        expiresAt: Date | string;
+    }>;
+    /**
+     * Verify the proof and issue a token. Throw an `McpToolError` to refuse; the
+     * answer's other fields (the signed-in address) are passed through.
+     */
+    login: (signed: SignedChallenge) => Promise<{
+        token: string;
+        expiresAt: Date | string;
+    } & Record<string, unknown>>;
+    /** Default 300, as `createRola`'s. */
+    challengeTtlSec?: number;
+    tokenTtlSec: number;
+    /** The calls the token is sent on, as in "create_page / edit_page". Default "tool". */
+    writeTools?: string;
+    notes?: {
+        /** A sentence added to `get_challenge`'s description. */
+        challenge?: string;
+        /** Lines added to, or replacing lines of, the signing recipe the challenge carries. */
+        sign?: Record<string, string>;
+        /** `login`'s `address` argument description. */
+        address?: string;
+    };
+}
+/**
+ * `get_challenge` and `login`, the two MCP tools that turn an agent's own key
+ * into a Bearer token: the challenge carries the exact message to sign, and a
+ * refused login says to start again, since a challenge is spent either way.
+ */
+export declare function rolaLoginTools(o: RolaLoginToolsOptions): Array<McpTool & Required<Pick<McpTool, 'title' | 'annotations'>>>;

package/dist/rola.js

@@ -17,6 +17,7 @@
 // `@radixdlt/rola` are optional peers, needed only by an app importing this.
 import { SignJWT, jwtVerify } from 'jose';
 import { Rola } from '@radixdlt/rola';
+import { McpToolError } from './mcp.js';
 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);
@@ -101,3 +102,83 @@ export async function verifySession(token, secret) {
 export function bearerToken(headers) {
     return headers.get('authorization')?.match(/^Bearer\s+(.+)$/i)?.[1] ?? null;
 }
+/** "12h", or "7-day" for whole days past one. */
+const span = (sec) => (sec % 86_400 === 0 && sec > 86_400 ? `${sec / 86_400}-day` : `${Math.round(sec / 3600)}h`);
+/**
+ * `get_challenge` and `login`, the two MCP tools that turn an agent's own key
+ * into a Bearer token: the challenge carries the exact message to sign, and a
+ * refused login says to start again, since a challenge is spent either way.
+ */
+export function rolaLoginTools(o) {
+    const minutes = (o.challengeTtlSec ?? 300) / 60;
+    const carries = o.writeTools ?? 'tool';
+    return [
+        {
+            name: 'get_challenge',
+            title: 'Start a login',
+            annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+            description: `Step 1 of writing to ${o.site}: a single-use ROLA challenge (${minutes}-minute expiry). ` +
+                'The response spells out the exact recipe for the message your Ed25519 key must sign. ' +
+                (o.notes?.challenge ? `${o.notes.challenge} ` : '') +
+                'You always sign with your OWN key — nothing here custodies anything. Takes no parameters.',
+            inputSchema: { type: 'object', properties: {} },
+            handler: async () => {
+                const { challenge, expiresAt } = await o.generateChallenge();
+                return {
+                    challenge,
+                    expiresAt: new Date(expiresAt).toISOString(),
+                    sign: {
+                        message: `blake2b-256 of: "R" (ascii) + challenge (hex-decoded) + one length byte of the dApp definition address "${o.dAppDefinitionAddress}" + that same address (utf-8) + the origin "${o.origin}" (utf-8)`,
+                        curve: 'curve25519 (Ed25519); sign the 32-byte hash, hex-encode the signature',
+                        address: 'your virtual account address, derived from your public key',
+                        ...o.notes?.sign,
+                        then: 'Call login with { challenge, address, publicKey, signature, curve }.',
+                    },
+                };
+            },
+        },
+        {
+            name: 'login',
+            title: 'Exchange a signed proof for a token',
+            annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+            description: `Step 2: exchange the signed ROLA proof for a ${span(o.tokenTtlSec)} Bearer token — the same verification the human wallet flow runs. ` +
+                `Send the returned token as an HTTP \`Authorization: Bearer <token>\` header on every later ${carries} call; tool arguments never carry it.`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    challenge: { type: 'string', description: 'The challenge from get_challenge' },
+                    address: { type: 'string', description: o.notes?.address ?? 'Your account address (virtual account of the signing key)' },
+                    publicKey: { type: 'string', description: 'Ed25519 public key, hex' },
+                    signature: { type: 'string', description: 'Signature over the ROLA message, hex' },
+                    curve: { type: 'string', enum: ['curve25519', 'secp256k1'], description: 'Signing curve (Ed25519 = "curve25519")' },
+                },
+                required: ['challenge', 'address', 'publicKey', 'signature', 'curve'],
+            },
+            handler: async (args) => {
+                const signed = {
+                    challenge: String(args.challenge),
+                    address: String(args.address),
+                    proof: { publicKey: String(args.publicKey), signature: String(args.signature), curve: args.curve },
+                };
+                try {
+                    const { token, expiresAt, ...rest } = await o.login(signed);
+                    return {
+                        token,
+                        tokenType: 'Bearer',
+                        expiresAt: new Date(expiresAt).toISOString(),
+                        ...rest,
+                        note: `Send as an HTTP \`Authorization: Bearer <token>\` header on the POSTs carrying your ${carries} calls.`,
+                    };
+                }
+                catch (err) {
+                    if (!(err instanceof McpToolError))
+                        throw err;
+                    throw new McpToolError(err.message, {
+                        hint: `Challenges are single-use and expire after ${minutes} minutes — call get_challenge again. The signing recipe is in its response.`,
+                        ...err.details,
+                    });
+                }
+            },
+        },
+    ];
+}

package/dist/taxonomy.d.ts

@@ -150,9 +150,8 @@ export interface Taxonomy {
         metadata?: unknown;
     }) => MetadataRow[];
     /**
-     * Whether a set has outgrown a grid: the one size rule a hub's browsing
-     * controls read. `alphaControls` applies it; a sort toggle reads it too, with
-     * the same unfiltered count, so the two appear and vanish together.
+     * Whether a set has outgrown a grid and needs an A–Z index. `alphaControls`
+     * applies it. The sort toggle does not: order matters to a short dated set too.
      */
     needsAlphaIndex: (pageCount: number) => boolean;
     href: (tagPath: string, state: CategoryState) => string;

package/dist/wiki-tools.d.ts

@@ -3,6 +3,8 @@ import { type CorpusSection } from './corpus.js';
 import { type WikiNode, type WikiTree } from './tree.js';
 import type { WikiStore, WikiPageListing, WikiPageRow, PageMetadata } from './store.js';
 import type { DiffBlock } from './revisions.js';
+/** The section a `corpus` callback returns, from the slicer this module keeps internal. */
+export type { CorpusSection };
 type ToolName = 'search_wiki' | 'get_page' | 'get_pages' | 'list_pages' | 'get_categories' | 'get_recent_changes' | 'get_full_corpus' | 'get_page_history';
 export interface WikiToolsOptions<B extends DiffBlock> {
     store: WikiStore<B>;
@@ -75,4 +77,3 @@ export declare function searchWiki<B extends DiffBlock>(o: Pick<WikiToolsOptions
     total: number;
 }>;
 export declare function wikiReadTools<B extends DiffBlock>(o: WikiToolsOptions<B>): WikiTool[];
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.97.1",
+  "version": "0.98.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",
@@ -157,11 +157,6 @@
       "import": "./dist/social.js",
       "default": "./dist/social.js"
     },
-    "./links": {
-      "types": "./dist/links.d.ts",
-      "import": "./dist/links.js",
-      "default": "./dist/links.js"
-    },
     "./maps": {
       "types": "./dist/maps.d.ts",
       "import": "./dist/maps.js",
@@ -273,11 +268,6 @@
       "import": "./dist/upload.js",
       "default": "./dist/upload.js"
     },
-    "./corpus": {
-      "types": "./dist/corpus.d.ts",
-      "import": "./dist/corpus.js",
-      "default": "./dist/corpus.js"
-    },
     "./metadata": {
       "types": "./dist/metadata.d.ts",
       "import": "./dist/metadata.js",