wiki-formant 0.107.0 → 0.112.0

package/dist/link-check.js

@@ -193,6 +193,9 @@ const YOUTUBE_WATCH = /^https?:\/\/(?:(?:www\.)?youtube\.com\/(?:watch\?(?:[^#]*
  * video. oEmbed can:
  *
  *   200 → public and embeddable | 404 → deleted | 401/403 → private or embedding off
+ *
+ * A 429 is YouTube rationing the sweep, walled as `attempt` walls it: read off
+ * its status alone, `verdictOf` called every video in a throttled run dead.
  */
 async function probeYouTube(videoId, opts = {}) {
     const { timeoutMs } = { ...DEFAULTS, ...opts };
@@ -208,7 +211,7 @@ async function probeYouTube(videoId, opts = {}) {
         if (res.status === 401 || res.status === 403) {
             return { status: res.status, ok: false, reason: 'restricted (private or embedding disabled)' };
         }
-        return { status: res.status, ok: res.status < 400 };
+        return { status: res.status, ok: res.status < 400, ...(res.status === 429 && { walled: true }) };
     }
     catch (err) {
         return { status: 0, ok: false, ...describeFailure(err) };

package/dist/openapi.d.ts

@@ -0,0 +1,139 @@
+import { type License } from './license.js';
+import { type ToolSchema } from './mcp.js';
+type Schema = Record<string, unknown>;
+export interface OpenApiInfo {
+    title: string;
+    /** The server version, the number the agent card and MCP `initialize` carry. */
+    version: string;
+    description: string;
+    license: License;
+    siteUrl: string;
+    contact?: {
+        name: string;
+        url: string;
+    };
+}
+/** The document: version, info, the one server, the paths, and components when there are any. */
+export declare function openApiDocument<P extends object, C extends object>(info: OpenApiInfo, paths: P, components?: C): {
+    components?: C | undefined;
+    openapi: "3.1.0";
+    info: {
+        license: {
+            name: string;
+            identifier: string;
+        };
+        contact?: {
+            name: string;
+            url: string;
+        } | undefined;
+        title: string;
+        version: string;
+        description: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    paths: P;
+};
+/** A required JSON request body. */
+export declare const jsonBody: (schema: Schema) => {
+    required: boolean;
+    content: {
+        'application/json': {
+            schema: Schema;
+        };
+    };
+};
+/** A JSON response, its schema left open when none is given. */
+export declare const jsonResponse: (description: string, schema?: Schema) => {
+    description: string;
+    content: {
+        'application/json': {
+            schema: Schema;
+        };
+    };
+};
+/**
+ * A tool's input schema as a REST body, less the fields the path carries. A
+ * property whose `items` is one of `refs` points at its component instead of
+ * inlining it, so a block schema is written once.
+ */
+export declare function toolBody(input: Pick<ToolSchema, 'properties' | 'required'>, { inPath, refs }?: {
+    inPath?: readonly string[];
+    refs?: Record<string, Schema>;
+}): {
+    required: boolean;
+    content: {
+        'application/json': {
+            schema: Schema;
+        };
+    };
+};
+/** The validator a recrawling agent sends: a match costs a 304 rather than the body. */
+export declare const IF_NONE_MATCH: {
+    name: string;
+    in: string;
+    required: boolean;
+    schema: {
+        type: string;
+    };
+    description: string;
+};
+export declare const NOT_MODIFIED: {
+    description: string;
+};
+/** `/llms.txt`, answered from one corpus validator. */
+export declare const llmsTxtPath: (summary: string) => {
+    get: {
+        summary: string;
+        parameters: {
+            name: string;
+            in: string;
+            required: boolean;
+            schema: {
+                type: string;
+            };
+            description: string;
+        }[];
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'text/plain': {};
+                };
+            };
+            '304': {
+                description: string;
+            };
+        };
+    };
+};
+/** An MCP endpoint: the tools it serves, and what every endpoint `mcpResponse` serves has in common. */
+export declare function mcpPath(tools: readonly string[], opts?: {
+    summary?: string;
+    note?: string;
+}): {
+    post: {
+        summary: string;
+        description: string;
+        requestBody: {
+            required: boolean;
+            content: {
+                'application/json': {
+                    schema: Schema;
+                };
+            };
+        };
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: Schema;
+                    };
+                };
+            };
+        };
+    };
+};
+export {};

package/dist/openapi.js

@@ -0,0 +1,75 @@
+// openapi.ts — the OpenAPI 3.1 frame every agent surface serves at
+// /.well-known/openapi.json.
+//
+// What is per-site is the paths only it has. The frame, the body and response
+// shapes, the conditional GET, the MCP endpoint and /llms.txt read the same on
+// every site, so they are built here and a spec carries only its own paths.
+import { openApiLicense } from './license.js';
+import { DEFAULT_MAX_BATCH, MCP_PROTOCOL_VERSIONS } from './mcp.js';
+import { MCP_RATE_LIMIT_TEXT } from './rate-limit.js';
+/** The document: version, info, the one server, the paths, and components when there are any. */
+export function openApiDocument(info, paths, components) {
+    const { title, version, description, license, siteUrl, contact } = info;
+    return {
+        openapi: '3.1.0',
+        info: { title, version, description, ...(contact ? { contact } : {}), license: openApiLicense(license) },
+        servers: [{ url: siteUrl }],
+        paths,
+        ...(components ? { components } : {}),
+    };
+}
+/** A required JSON request body. */
+export const jsonBody = (schema) => ({ required: true, content: { 'application/json': { schema } } });
+/** A JSON response, its schema left open when none is given. */
+export const jsonResponse = (description, schema = {}) => ({
+    description,
+    content: { 'application/json': { schema } },
+});
+/**
+ * A tool's input schema as a REST body, less the fields the path carries. A
+ * property whose `items` is one of `refs` points at its component instead of
+ * inlining it, so a block schema is written once.
+ */
+export function toolBody(input, { inPath = [], refs = {} } = {}) {
+    const kept = (k) => !inPath.includes(k);
+    const ref = (items) => Object.entries(refs).find(([, s]) => s === items)?.[0];
+    return jsonBody({
+        type: 'object',
+        required: input.required?.filter(kept),
+        properties: Object.fromEntries(Object.entries(input.properties)
+            .filter(([k]) => kept(k))
+            .map(([k, v]) => {
+            const name = ref(v.items);
+            return [k, name ? { ...v, items: { $ref: `#/components/schemas/${name}` } } : v];
+        })),
+    });
+}
+/** The validator a recrawling agent sends: a match costs a 304 rather than the body. */
+export const IF_NONE_MATCH = {
+    name: 'If-None-Match',
+    in: 'header',
+    required: false,
+    schema: { type: 'string' },
+    description: 'ETag from an earlier fetch. A match returns 304 with no body.',
+};
+export const NOT_MODIFIED = { description: 'Unchanged since the supplied validator' };
+/** `/llms.txt`, answered from one corpus validator. */
+export const llmsTxtPath = (summary) => ({
+    get: {
+        summary,
+        parameters: [IF_NONE_MATCH],
+        responses: { '200': { description: 'OK', content: { 'text/plain': {} } }, '304': NOT_MODIFIED },
+    },
+});
+/** An MCP endpoint: the tools it serves, and what every endpoint `mcpResponse` serves has in common. */
+export function mcpPath(tools, opts = {}) {
+    return {
+        post: {
+            summary: opts.summary ?? 'MCP server (JSON-RPC 2.0, Streamable HTTP)',
+            description: `Model Context Protocol ${MCP_PROTOCOL_VERSIONS.join(', ')}. Tools: ${tools.join(', ')}. ` +
+                `${opts.note ? `${opts.note} ` : ''}Batches are capped at ${DEFAULT_MAX_BATCH}; rate limit ${MCP_RATE_LIMIT_TEXT}.`,
+            requestBody: jsonBody({ type: 'object', description: 'JSON-RPC 2.0 request or batch' }),
+            responses: { '200': jsonResponse('JSON-RPC 2.0 response') },
+        },
+    };
+}

package/dist/react.d.ts

@@ -385,7 +385,8 @@ export declare function restoreViaPost<Id>(endpoint: string): RestoreRevision<Id
  * Confirm, restore, report. Of the three copies one asked no confirmation, one
  * dropped a failure silently, and one reported it through `alert`. A restore
  * writes the old state forward as a new revision in all three, which is what
- * the default question says.
+ * the default question says. A `restore` that throws is a failure like one
+ * that answers with its reason: it shows as `error`, never as nothing.
  */
 export declare function useRevisionRestore<Id>(restore: RestoreRevision<Id>, options: {
     onRestored: () => void;
@@ -433,6 +434,13 @@ export interface SnapRow<T extends HTMLElement> {
  * there reads as broken. Motion honours `prefers-reduced-motion`.
  */
 export declare function useSnapRow<T extends HTMLElement = HTMLDivElement>(): SnapRow<T>;
+/** The boundary's children render, or what they threw does: a thrown `null` is still a failure. */
+type BoundaryState = {
+    status: 'ok';
+} | {
+    status: 'failed';
+    error: unknown;
+};
 /**
  * The one thing hooks cannot express, so it is worth owning once.
  *
@@ -449,18 +457,9 @@ export declare class ErrorBoundary extends Component<{
      */
     fallback: (retry: () => void, error: unknown) => ReactNode;
     onError?: (error: unknown) => void;
-}, {
-    failed: boolean;
-    error: unknown;
-}> {
-    state: {
-        failed: boolean;
-        error: unknown;
-    };
-    static getDerivedStateFromError(error: unknown): {
-        failed: boolean;
-        error: unknown;
-    };
+}, BoundaryState> {
+    state: BoundaryState;
+    static getDerivedStateFromError(error: unknown): BoundaryState;
     componentDidCatch(error: unknown): void;
     render(): ReactNode;
 }

package/dist/react.js

@@ -52,8 +52,10 @@ function useCollapsibleSidebar(options = {}) {
     // Start open on the server and on the first client paint. SSR has no viewport
     // and no storage, so any other guess is a guaranteed mismatch on some loads.
     const [open, setOpenState] = useState(true);
-    const [isMobile, setIsMobile] = useState(false);
-    const [ready, setReady] = useState(false);
+    // Unknown until the effect has read matchMedia: one value, so the rail is
+    // never mobile before it is ready, and `ready` is never set apart from it.
+    const [viewport, setViewport] = useState('unknown');
+    const ready = viewport !== 'unknown';
     // Set as soon as the reader touches the control, so a later viewport change
     // cannot overwrite what they asked for.
     const chosen = useRef(false);
@@ -61,7 +63,7 @@ function useCollapsibleSidebar(options = {}) {
         const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
         const stored = readStored(storageKey);
         const apply = (matches) => {
-            setIsMobile(matches);
+            setViewport(matches ? 'mobile' : 'desktop');
             // The breakpoint supplies a default, never an override. This is bug 1.
             setOpenState(current => resolveSidebarOpen({ chosen: chosen.current, current, stored, isMobile: matches }));
             // The same number lives in the stylesheet, and must. Say so out loud the
@@ -79,7 +81,6 @@ function useCollapsibleSidebar(options = {}) {
             }
         };
         apply(mql.matches);
-        setReady(true);
         const handler = (e) => apply(e.matches);
         mql.addEventListener('change', handler);
         return () => mql.removeEventListener('change', handler);
@@ -106,7 +107,7 @@ function useCollapsibleSidebar(options = {}) {
             return;
         document.documentElement.setAttribute(SIDEBAR_ATTRIBUTE, open ? 'open' : 'closed');
     }, [open, ready]);
-    return { open, setOpen, toggle, isMobile, ready };
+    return { open, setOpen, toggle, isMobile: viewport === 'mobile', ready };
 }
 // ---- sharing that state across the layout -----------------------------------
 // The rail and the button that toggles it are rarely siblings — the button
@@ -756,11 +757,11 @@ export function restoreViaPost(endpoint) {
  * Confirm, restore, report. Of the three copies one asked no confirmation, one
  * dropped a failure silently, and one reported it through `alert`. A restore
  * writes the old state forward as a new revision in all three, which is what
- * the default question says.
+ * the default question says. A `restore` that throws is a failure like one
+ * that answers with its reason: it shows as `error`, never as nothing.
  */
 export function useRevisionRestore(restore, options) {
-    const [busyId, setBusyId] = useState(null);
-    const [error, setError] = useState(null);
+    const [state, setState] = useState({ status: 'idle' });
     // One restore at a time: a second, started while the first is in flight,
     // would have its "Restoring…" cleared by the first one finishing.
     const inFlight = useRef(false);
@@ -772,21 +773,26 @@ export function useRevisionRestore(restore, options) {
         if (question && !window.confirm(question))
             return;
         inFlight.current = true;
-        setBusyId(id);
-        setError(null);
+        setState({ status: 'restoring', id });
+        let failure;
         try {
-            const failure = await restore(id);
-            if (failure)
-                setError(failure);
-            else
-                onRestored();
+            failure = await restore(id);
+        }
+        catch (err) {
+            failure = err instanceof Error && err.message ? err.message : 'Restore failed.';
         }
         finally {
             inFlight.current = false;
-            setBusyId(null);
         }
+        setState(failure ? { status: 'failed', error: failure } : { status: 'idle' });
+        if (!failure)
+            onRestored();
     }, [restore, onRestored, confirm]);
-    return { restore: run, busyId, error };
+    return {
+        restore: run,
+        busyId: state.status === 'restoring' ? state.id : null,
+        error: state.status === 'failed' ? state.error : null,
+    };
 }
 // ---- copy to clipboard ------------------------------------------------------
 /**
@@ -866,7 +872,6 @@ export function useSnapRow() {
 }
 const snapEnd = (row) => row.scrollWidth - row.clientWidth;
 const snapTo = (row, left, smooth = true) => row.scrollTo({ left, behavior: smooth && !matchMedia('(prefers-reduced-motion: reduce)').matches ? 'smooth' : 'auto' });
-// ---- error boundary ---------------------------------------------------------
 /**
  * The one thing hooks cannot express, so it is worth owning once.
  *
@@ -876,16 +881,16 @@ const snapTo = (row, left, smooth = true) => row.scrollTo({ left, behavior: smoo
  * caller's, and the boundary only decides when to offer it.
  */
 export class ErrorBoundary extends Component {
-    state = { failed: false, error: null };
+    state = { status: 'ok' };
     static getDerivedStateFromError(error) {
-        return { failed: true, error };
+        return { status: 'failed', error };
     }
     componentDidCatch(error) {
         this.props.onError?.(error);
     }
     render() {
-        if (this.state.failed) {
-            return this.props.fallback(() => this.setState({ failed: false, error: null }), this.state.error);
+        if (this.state.status === 'failed') {
+            return this.props.fallback(() => this.setState({ status: 'ok' }), this.state.error);
         }
         return this.props.children;
     }

package/dist/stats-figures.d.ts

@@ -20,8 +20,13 @@ export interface PasskeyButtonProps {
     errorClassName?: string;
 }
 export declare function PasskeyButton({ endpoint, invite, className, errorClassName }: PasskeyButtonProps): import("react").JSX.Element;
-/** Ends the session at `endpoint` (`gate.signOut` as DELETE) and reloads the page. */
-export declare function PasskeySignOut({ endpoint, className }: {
+/**
+ * Ends the session at `endpoint` (`gate.signOut` as DELETE) and reloads the
+ * page. A sign-out the server did not take says so: reloaded, it showed the
+ * stats again with no word of why.
+ */
+export declare function PasskeySignOut({ endpoint, className, errorClassName }: {
     endpoint: string;
     className?: string;
+    errorClassName?: string;
 }): import("react").JSX.Element;

package/dist/stats-figures.js

@@ -96,13 +96,12 @@ async function post(endpoint, body) {
         throw new Error((await res.json().catch(() => null))?.error ?? 'Sign-in failed.');
     return res.status === 204 ? null : res.json();
 }
+const IDLE = { status: 'idle' };
 export function PasskeyButton({ endpoint, invite, className, errorClassName }) {
     const saving = !!invite;
-    const [busy, setBusy] = useState(false);
-    const [error, setError] = useState(null);
+    const [attempt, setAttempt] = useState(IDLE);
     async function go() {
-        setBusy(true);
-        setError(null);
+        setAttempt({ status: 'busy' });
         try {
             const optionsJSON = await post(endpoint, { invite });
             const response = saving ? await startRegistration({ optionsJSON }) : await startAuthentication({ optionsJSON });
@@ -111,16 +110,24 @@ export function PasskeyButton({ endpoint, invite, className, errorClassName }) {
         }
         catch (e) {
             // A prompt the person closed throws NotAllowedError, which needs no message.
-            setError(e instanceof Error && e.name !== 'NotAllowedError' ? e.message : null);
-            setBusy(false);
+            setAttempt(e instanceof Error && e.name !== 'NotAllowedError' ? { status: 'failed', error: e.message } : IDLE);
         }
     }
-    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: className, onClick: go, disabled: busy, children: saving ? 'Save a passkey' : 'Sign in with a passkey' }), error && (_jsx("p", { role: "alert", className: errorClassName, children: error }))] }));
+    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: className, onClick: go, disabled: attempt.status === 'busy', children: saving ? 'Save a passkey' : 'Sign in with a passkey' }), attempt.status === 'failed' && (_jsx("p", { role: "alert", className: errorClassName, children: attempt.error }))] }));
 }
-/** Ends the session at `endpoint` (`gate.signOut` as DELETE) and reloads the page. */
-export function PasskeySignOut({ endpoint, className }) {
-    return (_jsx("button", { type: "button", className: className, onClick: async () => {
-            await fetch(endpoint, { method: 'DELETE' }).catch(() => null);
-            location.reload();
-        }, children: "Sign out" }));
+/**
+ * Ends the session at `endpoint` (`gate.signOut` as DELETE) and reloads the
+ * page. A sign-out the server did not take says so: reloaded, it showed the
+ * stats again with no word of why.
+ */
+export function PasskeySignOut({ endpoint, className, errorClassName }) {
+    const [attempt, setAttempt] = useState(IDLE);
+    async function go() {
+        setAttempt({ status: 'busy' });
+        const res = await fetch(endpoint, { method: 'DELETE' }).catch(() => null);
+        if (res?.ok)
+            return location.reload();
+        setAttempt({ status: 'failed', error: res ? `Sign-out failed (${res.status}). Try again.` : 'Sign-out did not reach the server. Try again.' });
+    }
+    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: className, onClick: go, disabled: attempt.status === 'busy', children: "Sign out" }), attempt.status === 'failed' && (_jsx("p", { role: "alert", className: errorClassName, children: attempt.error }))] }));
 }

package/dist/stats.d.ts

@@ -26,9 +26,10 @@ export declare function statsQuery(params: Record<string, string | string[] | un
 /**
  * A site's own analytics on one page: the headline figures against the window
  * before, people and agents apart, whichever of them is chosen per day, and every ranked list the
- * digest carries, each row a link that narrows the page to it. Lists with
- * nothing in them are left out, but for the searches that found nothing,
- * which says it found none, so a quiet window never reads as one not counted. The chart and the bars are `currentColor`
+ * digest carries, each row a link that narrows the page to it, and what agents
+ * reported through `send_feedback`. Lists with nothing in them are left out,
+ * but for the searches and the feedback, which say they found none, so a quiet
+ * window never reads as one not counted. The chart and the bars are `currentColor`
  * until the importing stylesheet gives them a colour.
  */
 export declare function Stats({ digest: d, days, filter, ranges, link: Link }: StatsProps): import("react").JSX.Element;

package/dist/stats.js

@@ -52,9 +52,10 @@ function StatsList({ title, rows, label = v => v, to, empty, link: Link, }) {
 /**
  * A site's own analytics on one page: the headline figures against the window
  * before, people and agents apart, whichever of them is chosen per day, and every ranked list the
- * digest carries, each row a link that narrows the page to it. Lists with
- * nothing in them are left out, but for the searches that found nothing,
- * which says it found none, so a quiet window never reads as one not counted. The chart and the bars are `currentColor`
+ * digest carries, each row a link that narrows the page to it, and what agents
+ * reported through `send_feedback`. Lists with nothing in them are left out,
+ * but for the searches and the feedback, which say they found none, so a quiet
+ * window never reads as one not counted. The chart and the bars are `currentColor`
  * until the importing stylesheet gives them a colour.
  */
 export function Stats({ digest: d, days, filter = {}, ranges = STATS_RANGES, link: Link = Anchor }) {
@@ -73,7 +74,7 @@ export function Stats({ digest: d, days, filter = {}, ranges = STATS_RANGES, lin
     const to = (k) => (v) => at({ ...filter, [k]: v });
     // Each window is another digest, so a link rather than a button, pinned with the chart's own controls.
     const controls = (_jsx("div", { role: "group", "aria-label": "Window", children: ranges.map(n => (_jsx(Link, { href: at(filter, n), "aria-current": n === days ? 'page' : undefined, prefetch: false, children: windowLabel(n) }, n))) }));
-    return (_jsxs("div", { className: "stats", children: [narrowed.length > 0 && (_jsxs("div", { className: "stats-filters", children: [_jsx("ul", { "aria-label": "Narrowed to", children: narrowed.map(k => (_jsx("li", { children: _jsxs(Link, { href: at({ ...filter, [k]: undefined }), title: "Remove", prefetch: false, children: [NAMES[k], ": ", k === 'country' ? country(filter[k]) : filter[k], " \u00D7"] }) }, k))) }), start < counted && d.counted_from && (_jsxs("p", { children: ["Narrowed figures start on ", d.counted_from, ", the first day this site counted its own visits."] }))] })), _jsx(StatsFigures, { digest: d, first: first, controls: controls }), _jsxs("div", { className: "stats-lists", children: [_jsx(StatsList, { link: Link, title: "Pages", rows: rows(d.top_pages, 'page', 'visitors'), to: to('page') }), _jsx(StatsList, { link: Link, title: "Entry pages", rows: rows(d.entry_pages, 'page', 'visitors'), to: to('entry') }), _jsx(StatsList, { link: Link, title: "Sources", rows: rows(d.top_sources, 'source', 'visitors'), to: to('source') }), _jsx(StatsList, { link: Link, title: "From X posts", rows: rows(d.from_posts, 'page', 'visitors'), to: v => at({ ...filter, source: 'x', entry: v }) }), _jsx(StatsList, { link: Link, title: "Sibling sites", rows: rows(d.sibling_referrals, 'source', 'visitors'), to: to('source') }), _jsx(StatsList, { link: Link, title: "Countries", rows: rows(d.countries, 'country', 'visitors'), label: country, to: to('country') }), _jsx(StatsList, { link: Link, title: "Devices", rows: rows(d.devices, 'device', 'visitors'), to: to('device') }), _jsx(StatsList, { link: Link, title: "Agents", rows: rows(d.top_agents, 'agent', 'visitors') }), _jsx(StatsList, { link: Link, title: "Agent tool calls", rows: rows(d.agent_tool_calls, 'tool', 'events') }), _jsx(StatsList, { link: Link, title: "Searches that found nothing", rows: rows(d.gaps, 'query', 'events'), empty: "None in this window." })] })] }));
+    return (_jsxs("div", { className: "stats", children: [narrowed.length > 0 && (_jsxs("div", { className: "stats-filters", children: [_jsx("ul", { "aria-label": "Narrowed to", children: narrowed.map(k => (_jsx("li", { children: _jsxs(Link, { href: at({ ...filter, [k]: undefined }), title: "Remove", prefetch: false, children: [NAMES[k], ": ", k === 'country' ? country(filter[k]) : filter[k], " \u00D7"] }) }, k))) }), start < counted && d.counted_from && (_jsxs("p", { children: ["Narrowed figures start on ", d.counted_from, ", the first day this site counted its own visits."] }))] })), _jsx(StatsFigures, { digest: d, first: first, controls: controls }), _jsxs("div", { className: "stats-lists", children: [_jsx(StatsList, { link: Link, title: "Pages", rows: rows(d.top_pages, 'page', 'visitors'), to: to('page') }), _jsx(StatsList, { link: Link, title: "Entry pages", rows: rows(d.entry_pages, 'page', 'visitors'), to: to('entry') }), _jsx(StatsList, { link: Link, title: "Sources", rows: rows(d.top_sources, 'source', 'visitors'), to: to('source') }), _jsx(StatsList, { link: Link, title: "From X posts", rows: rows(d.from_posts, 'page', 'visitors'), to: v => at({ ...filter, source: 'x', entry: v }) }), _jsx(StatsList, { link: Link, title: "Sibling sites", rows: rows(d.sibling_referrals, 'source', 'visitors'), to: to('source') }), _jsx(StatsList, { link: Link, title: "Countries", rows: rows(d.countries, 'country', 'visitors'), label: country, to: to('country') }), _jsx(StatsList, { link: Link, title: "Devices", rows: rows(d.devices, 'device', 'visitors'), to: to('device') }), _jsx(StatsList, { link: Link, title: "Agents", rows: rows(d.top_agents, 'agent', 'visitors') }), _jsx(StatsList, { link: Link, title: "Agent tool calls", rows: rows(d.agent_tool_calls, 'tool', 'events') }), _jsx(StatsList, { link: Link, title: "Searches", rows: rows(d.searches, 'query', 'events'), empty: "None in this window." }), _jsx(StatsList, { link: Link, title: "Agent searches", rows: rows(d.agent_searches, 'query', 'events'), empty: "None in this window." }), _jsx(StatsList, { link: Link, title: "Searches that found nothing", rows: rows(d.gaps, 'query', 'events'), empty: "None in this window." }), _jsxs("section", { className: "stats-list", children: [_jsx("h2", { children: "Agent feedback" }), d.agent_feedback.length ? (_jsx("ol", { children: d.agent_feedback.map((f, i) => (_jsxs("li", { children: [_jsxs("span", { children: [f.kind, ": ", f.message, f.page && ` (${f.page})`, " \u00B7 ", f.agent] }), _jsx("span", { className: "stats-count", children: f.date })] }, i))) })) : (_jsx("p", { children: "None in this window." }))] })] })] }));
 }
 /**
  * A stats page's door: `children` and a sign-out button for a signed-in
@@ -83,7 +84,7 @@ export function Stats({ digest: d, days, filter = {}, ranges = STATS_RANGES, lin
  */
 export async function StatsGate({ gate, session, invite, host, endpoint = '/api/passkey', children, classNames: c = {} }) {
     if (!invite && (await gate.signedIn(session))) {
-        return (_jsxs(_Fragment, { children: [await children(), _jsx("div", { className: c.actions, children: _jsx(PasskeySignOut, { endpoint: endpoint, className: c.button }) })] }));
+        return (_jsxs(_Fragment, { children: [await children(), _jsx("div", { className: c.actions, children: _jsx(PasskeySignOut, { endpoint: endpoint, className: c.button, errorClassName: c.error }) })] }));
     }
     return (_jsxs(_Fragment, { children: [_jsx("p", { className: c.text, children: invite ? `Save a passkey on this device to open ${host}'s stats.` : 'Sign in with a passkey saved for this site.' }), _jsx("div", { className: c.actions, children: _jsx(PasskeyButton, { endpoint: endpoint, invite: invite, className: c.button, errorClassName: c.error }) })] }));
 }

package/dist/well-known.d.ts

@@ -50,13 +50,7 @@ export interface AgentCardConfig {
     /** Anything this origin advertises that the others do not. */
     extra?: Record<string, unknown>;
 }
-/**
- * An A2A Agent Card. Serve the same object at both `/.well-known/agent.json`
- * and `/.well-known/agent-card.json`: v0.3 renamed the path and defined no
- * fallback in either direction, so a spec-current client probes only the new
- * one and a client on an older SDK probes only the old one. Serving one path
- * means half the callers conclude the origin has no agent at all.
- */
+/** An A2A Agent Card, served at `/.well-known/agent-card.json`, the path A2A v0.3 names. */
 export declare function agentCard(config: AgentCardConfig): Record<string, unknown>;
 /** The registry manifest (`server.json`) fields a card projects. */
 export interface ServerManifest {
@@ -150,7 +144,7 @@ export declare function descriptorHandler(body: unknown, opts?: {
 /** The whole `<mcp-url>/server-card` route, projected from server.json. */
 export declare const serverCardHandler: (manifest: ServerManifest) => ((request: Request) => Response);
 export interface WellKnownDocs {
-    /** Served at both `agent.json` and `agent-card.json`. */
+    /** `agent-card.json`. */
     agentCard?: unknown;
     /** `mcp.json`. */
     mcpManifest?: unknown;

package/dist/well-known.js

@@ -67,13 +67,7 @@ export function skillsFromTools(tools) {
  * origins here were serving one.
  */
 const A2A_PROTOCOL_VERSION = '0.3.0';
-/**
- * An A2A Agent Card. Serve the same object at both `/.well-known/agent.json`
- * and `/.well-known/agent-card.json`: v0.3 renamed the path and defined no
- * fallback in either direction, so a spec-current client probes only the new
- * one and a client on an older SDK probes only the old one. Serving one path
- * means half the callers conclude the origin has no agent at all.
- */
+/** An A2A Agent Card, served at `/.well-known/agent-card.json`, the path A2A v0.3 names. */
 export function agentCard(config) {
     const { name, description, url, version, skills, license, licenseScope, organization, documentationUrl, mcpEndpoint, extra } = config;
     const endpoint = mcpEndpoint === null ? url : (mcpEndpoint ?? `${url}/api/mcp`);
@@ -234,7 +228,6 @@ export function wellKnownHandler(docs) {
         : typeof auth === 'function' ? auth
             : registryAuthHandler(auth?.publicKey ?? process.env.MCP_REGISTRY_PUBLIC_KEY, auth?.keyType ?? process.env.MCP_REGISTRY_KEY_TYPE);
     const served = {
-        'agent.json': docs.agentCard === undefined ? undefined : descriptorHandler(docs.agentCard),
         'agent-card.json': docs.agentCard === undefined ? undefined : descriptorHandler(docs.agentCard),
         'mcp.json': docs.mcpManifest === undefined ? undefined : descriptorHandler(docs.mcpManifest),
         'openapi.json': docs.openapi === undefined ? undefined : descriptorHandler(docs.openapi),

package/dist/wiki-tools.d.ts

@@ -40,6 +40,12 @@ export interface WikiToolsOptions<B extends DiffBlock> {
     corpus?: (tagPath?: string) => Promise<CorpusSection[]>;
     /** What an empty search says. */
     noMatch?: (query: string, tagPath?: string) => string;
+    /**
+     * Each `search_wiki` query, on its first page, with how many pages it found:
+     * `(request, q, n) => trackSearch(request.headers, q, n, MCP_SURFACE)`, so the
+     * stats page lists what agents searched for beside what people did.
+     */
+    onSearch?: (request: Request, query: string, results: number) => void;
     /** A2A skills by tool, beside the defaults. */
     skills?: Partial<Record<ToolName, McpTool['skill']>>;
 }

package/dist/wiki-tools.js

@@ -129,7 +129,7 @@ export function wikiReadTools(o) {
                 },
                 required: ['query'],
             },
-            handler: async (args) => {
+            handler: async (args, ctx) => {
                 const r = readArgs(args);
                 const query = r.str('query');
                 const tagPath = r.str('tagPath') || undefined;
@@ -138,6 +138,8 @@ export function wikiReadTools(o) {
                 if (!query)
                     throw new McpToolError('`query` is empty. Pass a keyword to search for, or call list_pages to enumerate a branch instead.');
                 const { items, total, corrected } = await searchWiki(o, query, { tagPath, page, size });
+                if (page === 1 && ctx.request)
+                    o.onSearch?.(ctx.request, query, total);
                 return withAdjustments(r, {
                     query,
                     ...(corrected ? { corrected } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.107.0",
+  "version": "0.112.0",
   "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",
@@ -258,6 +258,11 @@
       "import": "./dist/og.js",
       "default": "./dist/og.js"
     },
+    "./openapi": {
+      "types": "./dist/openapi.d.ts",
+      "import": "./dist/openapi.js",
+      "default": "./dist/openapi.js"
+    },
     "./sanitize": {
       "types": "./dist/sanitize.d.ts",
       "import": "./dist/sanitize.js",