wiki-formant 0.48.0 → 0.50.0

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

package/dist/text.js

@@ -24,6 +24,38 @@ export function stripHtml(html) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
+/**
+ * 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 function plainText(html) {
+    return decodeEntities(html.replace(/<[^>]+>/g, ' '))
+        .replace(/\s+/g, ' ')
+        .replace(/\s+([,.;:!?%)\]])/g, '$1')
+        .replace(/([(\[])\s+/g, '$1')
+        .trim();
+}
+const HEADINGS = /<h[1-6][^>]*>[\s\S]*?<\/h[1-6]>/gi;
+/**
+ * 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 function openingText(blocks) {
+    for (const block of Array.isArray(blocks) ? blocks : []) {
+        if (block?.type !== 'content' || typeof block.text !== 'string')
+            continue;
+        const text = plainText(block.text.replace(HEADINGS, ''));
+        if (text)
+            return text;
+    }
+    return '';
+}
 /**
  * Display labels for the maintenance banners. Canonical: the prose extractor,
  * the markdown twin and the MDX export all render the same six strings.
@@ -54,15 +86,15 @@ export const BANNER_VARIANTS = Object.keys(BANNER_LABELS).map(value => ({
 export function bannerVariant(variant) {
     return Object.hasOwn(BANNER_LABELS, variant) ? variant : 'cleanup';
 }
-/** A maintenance notice, inline: `[Notice: Needs citations] …`. */
+/** A maintenance notice, inline: `[Notice: Needs citations] …`. @internal */
 export function bannerToText(label, text) {
     return `[Notice: ${label}]${text ? ' ' + stripHtml(text) : ''}`;
 }
-/** Each tab under its label, tags stripped — highlighted markup is noise here. */
+/** Each tab under its label, tags stripped — highlighted markup is noise here. @internal */
 export function codeTabsToText(tabs) {
     return tabs.map(t => `[${t.label}]\n${t.code}`).join('\n');
 }
-/** Metric cards, one per line: `99% Uptime`. */
+/** Metric cards, one per line: `99% Uptime`. @internal */
 export function statsToText(items) {
     return items.map(s => `${s.value}${s.suffix ?? ''} ${s.label}`).join('\n');
 }
@@ -73,6 +105,8 @@ export function statsToText(items) {
  * 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.
+ *
+ * @internal
  */
 export function linkGridToText(groups, intro) {
     return [
@@ -84,11 +118,11 @@ export function linkGridToText(groups, intro) {
         ].join('\n')),
     ].join('\n\n');
 }
-/** A resolved page list: one title per line. */
+/** A resolved page list: one title per line. @internal */
 export function pageListToText(pages) {
     return pages.map(p => p.title).join('\n');
 }
-/** A numbered reference list, or `''` when there are none. */
+/** A numbered reference list, or `''` when there are none. @internal */
 export function referencesToText(items) {
     if (!items.length)
         return '';

package/dist/tiptap.d.ts

@@ -34,9 +34,10 @@ export interface CodeBlockClassNames {
     optionActive?: string;
 }
 export interface CodeBlockOptions {
-    /** Selectable languages. Each wiki's own list, from its block-utils. */
-    langs: readonly string[];
-    defaultLang: string;
+    /** Selectable languages. Default `CODE_LANGS`. */
+    langs?: readonly string[];
+    /** Default `DEFAULT_LANG`. */
+    defaultLang?: string;
     classNames?: CodeBlockClassNames;
     icons?: {
         lang?: ReactNode;
@@ -46,7 +47,7 @@ export interface CodeBlockOptions {
     };
 }
 /** A code block whose language is pickable from a dropdown. */
-export declare function createCodeBlock({ langs, defaultLang, classNames, icons, }: CodeBlockOptions): TiptapNode<import("@tiptap/extension-code-block").CodeBlockOptions, any>;
+export declare function createCodeBlock({ langs, defaultLang, classNames, icons, }?: CodeBlockOptions): TiptapNode<import("@tiptap/extension-code-block").CodeBlockOptions, any>;
 export interface TabsClassNames {
     editor?: string;
     list?: string;

package/dist/tiptap.js

@@ -23,6 +23,7 @@ import { toMapEmbedUrl } from './maps.js';
 import { useClickOutside } from './react.js';
 import { cx } from './html.js';
 import { slugifyHeading, uniqueHeadingId } from './headings.js';
+import { CODE_LANGS, DEFAULT_LANG } from './blocks.js';
 /** Local `cn`. Both wikis import one; the package will not depend on one. */
 // ---- iframe -----------------------------------------------------------------
 export const Iframe = TiptapNode.create({
@@ -216,7 +217,7 @@ export function createMapEmbed({ resolveMapUrl }) {
     });
 }
 /** A code block whose language is pickable from a dropdown. */
-export function createCodeBlock({ langs, defaultLang, classNames = {}, icons = {}, }) {
+export function createCodeBlock({ langs = CODE_LANGS, defaultLang = DEFAULT_LANG, classNames = {}, icons = {}, } = {}) {
     function CodeBlockView({ node, updateAttributes, }) {
         const [open, setOpen] = useState(false);
         const close = useCallback(() => setOpen(false), []);

package/dist/upload.d.ts

@@ -0,0 +1,45 @@
+import { type Sharp } from 'sharp';
+import { type RateLimitOptions } from './rate-limit.js';
+export type ImageFormat = 'jpg' | 'png' | 'gif' | 'webp' | 'avif';
+type Encode = (image: Sharp, source: {
+    format: ImageFormat;
+    width: number;
+    height: number;
+}) => {
+    image: Sharp;
+    format: ImageFormat;
+};
+export interface NormalizeOptions {
+    /** Decoded pixels, default 40 million: a phone camera's full resolution. */
+    maxPixels?: number;
+    /**
+     * How the upright image is written. Default the format it arrived in. A wiki
+     * with an image standard resizes and converts here.
+     */
+    encode?: Encode;
+}
+/**
+ * The image re-encoded upright with no metadata, in the format `encode` chose.
+ * Throws, with a message fit to show the uploader, for bytes that are not an
+ * accepted image or decode to more than `maxPixels`.
+ */
+export declare function normalizeImage(bytes: Buffer, { maxPixels, encode, }?: NormalizeOptions): Promise<{
+    buffer: Buffer;
+    format: ImageFormat;
+    contentType: string;
+}>;
+export interface UploadOptions extends NormalizeOptions {
+    /** The uploader's id, which keys the rate limit, or the response that turns them away. */
+    authorize: (request: Request) => Promise<string | Response>;
+    /** Default 4 MB. */
+    maxBytes?: number;
+    /** Default a burst of 20, then one every five seconds. */
+    rateLimit?: RateLimitOptions;
+    /** Prepended to the stored name, e.g. `wiki/`. */
+    prefix?: string;
+    /** Stores the bytes and resolves to their public URL. Default Vercel Blob, public. */
+    store?: (path: string, body: Buffer, contentType: string) => Promise<string>;
+}
+/** The POST handler: a multipart `file` in, `{ url }` out. */
+export declare function uploadHandler({ authorize, maxBytes, maxPixels, rateLimit, encode, prefix, store, }: UploadOptions): (request: Request) => Promise<Response>;
+export {};