wiki-formant 0.13.0 → 0.16.0

package/dist/react-server.d.ts

@@ -13,9 +13,18 @@ export interface WikiLinkProps {
     className?: string;
     title?: string;
     'aria-current'?: 'true' | 'page' | undefined;
+    /** `prev`/`next` on the foot nav — the half that makes the pair machine-readable. */
+    rel?: string;
     children?: ReactNode;
 }
 export type WikiLinkComponent = ComponentType<WikiLinkProps>;
+/**
+ * The default for anything that does not need client-side navigation.
+ *
+ * Exported because `block-views` renders links too and had declared the same
+ * three lines; a default that exists twice is a default that can diverge.
+ */
+export declare const Anchor: WikiLinkComponent;
 /**
  * Class names differ per wiki and always will — unlike the rail's `wiki-rail__*`
  * tree, which is a shared convention, these are each design system's own words
@@ -50,29 +59,102 @@ export interface FacetBarProps {
 export declare function FacetBar({ link: Link, facets, letters, alphaLabel, classNames, }: FacetBarProps): import("react").JSX.Element | null;
 export interface BreadcrumbItem {
     label: string;
-    href: string;
+    /**
+     * Omit to render the crumb as plain text rather than a link — a section that
+     * groups pages but has no page of its own. A crumb with no href is left out
+     * of the `BreadcrumbList` too, since a `ListItem` with no `item` is invalid.
+     */
+    href?: string;
 }
 export interface BreadcrumbsProps {
     items: BreadcrumbItem[];
     /**
      * Origin the JSON-LD `item` URLs are resolved against, without a trailing
      * slash. Structured-data URLs must be absolute — Google rejects relative
-     * paths — and this package cannot know the site it is rendering for.
+     * paths — and this package cannot know the site it is rendering for. Omit it
+     * to render the trail with no structured data at all.
      */
-    base: string;
+    base?: string;
     className?: string;
     /** Defaults to a plain `<a>`, which is what a crumb trail wants. */
     link?: WikiLinkComponent;
+    /**
+     * What the final crumb renders as.
+     *
+     * `h1` is not decoration: on a wiki whose page title IS the last crumb, the
+     * trail and the heading are the same words, and rendering both means either
+     * saying it twice or shipping a page with no h1 at all. The `breadcrumb-h1`
+     * class carries the size difference.
+     */
+    lastAs?: 'span' | 'h1';
+    /**
+     * Fewest crumbs worth rendering. Default 2 — one crumb is not a trail.
+     *
+     * A wiki whose last crumb doubles as the page heading passes 1, because there
+     * the single crumb is not a trail either, it is the title.
+     */
+    minItems?: number;
 }
 /**
  * The trail, plus the `BreadcrumbList` that makes it a rich result.
  *
- * The two are emitted together on purpose: a trail whose JSON-LD is written
+ * THE TWO ARE EMITTED TOGETHER ON PURPOSE. A trail whose JSON-LD is written
  * somewhere else is a trail that will one day disagree with its own markup, and
- * Google penalises exactly that.
+ * Google penalises exactly that. Both wikis had proved the point before
+ * adopting this: each rendered its crumbs in a component and built its
+ * `BreadcrumbList` in a different file — a page module in one, a `*-ld.ts` in
+ * the other — and one of them carried a comment noting the risk it was taking.
+ *
+ * Markup is a `<nav>` wrapping an `<ol>`: a breadcrumb trail is an ordered list
+ * and assistive technology announces it as one. The separators are list items
+ * marked `aria-hidden`, so they are not read out as content.
+ */
+export declare function Breadcrumbs({ items, base, className, link: Link, lastAs, minItems, }: BreadcrumbsProps): import("react").JSX.Element | null;
+/**
+ * The standard page-top row: the trail, plus optional right-aligned actions.
+ *
+ * The column it sits in is the one its route declares — the row reads the
+ * page's own max-width by inheritance, so a trail can no longer disagree with
+ * the content it titles.
+ */
+export declare function BreadcrumbsRow({ actions, className, ...props }: BreadcrumbsProps & {
+    actions?: ReactNode;
+}): import("react").JSX.Element;
+/** One end of the foot nav: where it goes and what it is called. */
+export interface PageNavRef {
+    title: string;
+    href: string;
+}
+export interface PageNavProps {
+    prev?: PageNavRef | null;
+    next?: PageNavRef | null;
+    link?: WikiLinkComponent;
+    /** The landmark's accessible name. */
+    label?: string;
+    prevLabel?: string;
+    nextLabel?: string;
+    /**
+     * The arrows. `ReactNode` rather than a string because both wikis draw them
+     * with an icon component, and this package is not acquiring an icon peer to
+     * hold two glyphs.
+     */
+    prevGlyph?: ReactNode;
+    nextGlyph?: ReactNode;
+}
+/**
+ * The sequential read at the foot of an article — the move the infobox rail's
+ * lateral links do not cover.
+ *
+ * Ordering is entirely the caller's; pair this with `adjacentPages` from
+ * `wiki-formant/pagination` over a list you already hold. Both wikis had this
+ * markup and had already drifted on the parts that matter rather than the parts
+ * that show: one carried `rel="prev"`/`rel="next"` and an `aria-label` and the
+ * other carried neither, and the one without expressed its right-hand alignment
+ * as two inline utilities instead of the modifier its own stylesheet defines.
  *
- * Renders nothing for a single crumb. One item is not a trail, and a
- * `BreadcrumbList` of length one is noise in the index.
+ * The `page-nav__*` class names are NOT props, for the reason `WikiRail`'s are
+ * not: they are the convention both stylesheets already implement, and making
+ * them configurable is how a convention forks. The empty `<div>` holds the
+ * first article's left column so the next link stays in the right one.
  */
-export declare function Breadcrumbs({ items, base, className, link: Link }: BreadcrumbsProps): import("react").JSX.Element | null;
-//# sourceMappingURL=react-server.d.ts.map
+export declare function PageNav({ prev, next, link: Link, label, prevLabel, nextLabel, prevGlyph, nextGlyph, }: PageNavProps): import("react").JSX.Element | null;

package/dist/react-server.js

@@ -19,8 +19,13 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // back to a full page load on every press. React is an optional peer, as it is
 // for `wiki-formant/react`.
 import { Fragment } from 'react';
-/** The default for anything that does not need client-side navigation. */
-const Anchor = ({ href, className, children }) => _jsx("a", { href: href, className: className, children: children });
+/**
+ * The default for anything that does not need client-side navigation.
+ *
+ * Exported because `block-views` renders links too and had declared the same
+ * three lines; a default that exists twice is a default that can diverge.
+ */
+export const Anchor = ({ href, className, children }) => _jsx("a", { href: href, className: className, children: children });
 /**
  * The section's second axis, as pressable chips.
  *
@@ -40,23 +45,70 @@ export function FacetBar({ link: Link, facets, letters, alphaLabel = 'A–Z', cl
 /**
  * The trail, plus the `BreadcrumbList` that makes it a rich result.
  *
- * The two are emitted together on purpose: a trail whose JSON-LD is written
+ * THE TWO ARE EMITTED TOGETHER ON PURPOSE. A trail whose JSON-LD is written
  * somewhere else is a trail that will one day disagree with its own markup, and
- * Google penalises exactly that.
+ * Google penalises exactly that. Both wikis had proved the point before
+ * adopting this: each rendered its crumbs in a component and built its
+ * `BreadcrumbList` in a different file — a page module in one, a `*-ld.ts` in
+ * the other — and one of them carried a comment noting the risk it was taking.
  *
- * Renders nothing for a single crumb. One item is not a trail, and a
- * `BreadcrumbList` of length one is noise in the index.
+ * Markup is a `<nav>` wrapping an `<ol>`: a breadcrumb trail is an ordered list
+ * and assistive technology announces it as one. The separators are list items
+ * marked `aria-hidden`, so they are not read out as content.
  */
-export function Breadcrumbs({ items, base, className = '', link: Link = Anchor }) {
-    if (!items || items.length <= 1)
+export function Breadcrumbs({ items, base, className = '', link: Link = Anchor, lastAs = 'span', minItems = 2, }) {
+    if (!items || items.length < minItems)
         return null;
     const absolute = (path) => /^https?:\/\//.test(path) ? path : `${base}${path.startsWith('/') ? path : `/${path}`}`;
-    return (_jsxs(_Fragment, { children: [_jsx("nav", { "aria-label": "Breadcrumb", className: `breadcrumbs ${className}`, children: _jsx("ol", { children: items.map((item, i) => (_jsxs(Fragment, { children: [i > 0 && _jsx("li", { className: "separator", "aria-hidden": "true", children: "/" }), _jsx("li", { children: i === items.length - 1 ? (_jsx("span", { className: "pl-4", "aria-current": "page", children: item.label })) : (_jsx(Link, { href: item.href, children: item.label })) })] }, item.href))) }) }), _jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: JSON.stringify({
-                        "@context": "https://schema.org",
-                        "@type": "BreadcrumbList",
-                        "itemListElement": items.map((item, i) => ({
-                            "@type": "ListItem", "position": i + 1, "name": item.label, "item": absolute(item.href)
-                        }))
-                    }) } })] }));
+    // A one-item list is noise in the index even where the trail is worth
+    // rendering. Every crumb is listed, but only a crumb with an href carries an
+    // `item`: schema.org's documented shape for the page you are already on is a
+    // final `ListItem` with a name and no URL, so dropping it would lose the leaf
+    // the trail exists to name.
+    const structured = base && items.length > 1;
+    return (_jsxs(_Fragment, { children: [_jsx("nav", { "aria-label": "Breadcrumb", className: `breadcrumbs ${className}`.trim(), children: _jsx("ol", { children: items.map((item, i) => {
+                        const isLast = i === items.length - 1;
+                        const Last = lastAs === 'h1' ? 'h1' : 'span';
+                        return (_jsxs(Fragment, { children: [i > 0 && _jsx("li", { className: "separator", "aria-hidden": "true", children: "/" }), _jsx("li", { children: isLast ? (_jsx(Last, { className: lastAs === 'h1' ? 'breadcrumb-h1' : 'breadcrumb-current', "aria-current": "page", children: item.label })) : item.href ? (_jsx(Link, { href: item.href, className: "breadcrumb-link", title: item.label, children: item.label })) : (_jsx("span", { className: "breadcrumb-current", children: item.label })) })] }, item.href ?? `${item.label}-${i}`));
+                    }) }) }), structured && (_jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: JSON.stringify({
+                        '@context': 'https://schema.org',
+                        '@type': 'BreadcrumbList',
+                        itemListElement: items.map((item, i) => ({
+                            '@type': 'ListItem',
+                            position: i + 1,
+                            name: item.label,
+                            ...(item.href ? { item: absolute(item.href) } : {}),
+                        })),
+                    }) } }))] }));
+}
+/**
+ * The standard page-top row: the trail, plus optional right-aligned actions.
+ *
+ * The column it sits in is the one its route declares — the row reads the
+ * page's own max-width by inheritance, so a trail can no longer disagree with
+ * the content it titles.
+ */
+export function BreadcrumbsRow({ actions, className = '', ...props }) {
+    return (_jsxs("div", { className: `breadcrumbs-row ${actions ? 'spread' : ''} ${className}`.trim(), children: [_jsx(Breadcrumbs, { ...props }), actions] }));
+}
+/**
+ * The sequential read at the foot of an article — the move the infobox rail's
+ * lateral links do not cover.
+ *
+ * Ordering is entirely the caller's; pair this with `adjacentPages` from
+ * `wiki-formant/pagination` over a list you already hold. Both wikis had this
+ * markup and had already drifted on the parts that matter rather than the parts
+ * that show: one carried `rel="prev"`/`rel="next"` and an `aria-label` and the
+ * other carried neither, and the one without expressed its right-hand alignment
+ * as two inline utilities instead of the modifier its own stylesheet defines.
+ *
+ * The `page-nav__*` class names are NOT props, for the reason `WikiRail`'s are
+ * not: they are the convention both stylesheets already implement, and making
+ * them configurable is how a convention forks. The empty `<div>` holds the
+ * first article's left column so the next link stays in the right one.
+ */
+export function PageNav({ prev, next, link: Link = Anchor, label = 'Article navigation', prevLabel = 'Previous', nextLabel = 'Next', prevGlyph = '\u2190', nextGlyph = '\u2192', }) {
+    if (!prev && !next)
+        return null;
+    return (_jsxs("nav", { className: "page-nav", "aria-label": label, children: [prev ? (_jsxs(Link, { href: prev.href, className: "page-nav-link", rel: "prev", children: [_jsxs("span", { className: "page-nav-label", children: [prevGlyph, prevLabel] }), _jsx("span", { className: "page-nav-title", children: prev.title })] })) : (_jsx("div", {})), next && (_jsxs(Link, { href: next.href, className: "page-nav-link page-nav-link--end", rel: "next", children: [_jsxs("span", { className: "page-nav-label page-nav-label--end", children: [nextLabel, nextGlyph] }), _jsx("span", { className: "page-nav-title", children: next.title })] }))] }));
 }
-//# sourceMappingURL=react-server.js.map

package/dist/react.d.ts

@@ -1,4 +1,3 @@
-import type { WikiLinkComponent } from './react-server.js';
 import { type ComboboxAria } from './combobox.js';
 import { Component, type CSSProperties, type KeyboardEvent, type ReactNode } from 'react';
 export interface SidebarOptions {
@@ -307,60 +306,50 @@ export declare class ErrorBoundary extends Component<{
     componentDidCatch(error: unknown): void;
     render(): ReactNode;
 }
-/** One entry in the rail's section list, with its href already built. */
-export interface RailSection {
-    href: string;
-    title: string;
-    glyph: string;
-    blurb?: string;
-}
-export interface WikiRailProps {
-    /**
-     * The router's link component.
-     *
-     * The rail takes it as a prop rather than importing one. This package has no
-     * `next` peer dependency and is not getting one — but a rail that falls back
-     * to a bare `<a>` turns every navigation into a full page load, which is the
-     * whole reason a wiki has a persistent rail. So the router stays the
-     * consumer's and arrives through the door.
-     */
-    link: WikiLinkComponent;
-    /** The path being rendered, for the active marker. */
-    activePath: string;
-    /** The wiki root's href. */
-    homeHref: string;
-    /** The wiki's sections with their hrefs already built, resolved server-side. */
-    sections: RailSection[];
+export interface RailShellProps {
+    children: ReactNode;
     /**
-     * The article's headings, empty on the home and section views.
+     * Class prefix the stylesheet implements: `"wiki-sidebar"` or `"sidebar"`.
      *
-     * Passing them is what lets `TableOfContents` skip its DOM scan and run no
-     * MutationObserver. A wiki whose block content streams in after the rail
-     * mounts leaves this empty and lets the scan do its job.
+     * The one thing genuinely per-repo here. Everything else — which three states
+     * exist, what each means, and that the attribute outranks the class — is a
+     * contract both stylesheets already spell out in near-identical comments.
      */
-    headings?: TocHeading[];
+    prefix: string;
+    /** Accessible name. A rail with none is an unlabelled landmark. */
     label?: string;
-    toggleLabel?: string;
-    homeLabel?: string;
-    homeGlyph?: string;
-    sectionsLabel?: string;
-    tocLabel?: string;
+    className?: string;
 }
 /**
- * The persistent left rail: home, table of contents, sections.
+ * The collapsible rail's outer shell: the landmark, its three states, and the
+ * scroll container, with a tap inside it closing the rail on mobile.
+ *
+ * THE THREE STATES ARE NOT TWO. `--open` / `--closed` is the reader's choice;
+ * `--instant` suppresses the transition until that choice has been read out of
+ * storage. Without the third, a rail the reader left closed renders open and
+ * then *slides shut* on every single load — and because the fix is invisible
+ * once it works, it is the part a reimplementation drops. Both rails that had
+ * this written out locally carried the same paragraph of comment explaining it,
+ * which is how you can tell it was learned twice.
+ *
+ * The class is not authoritative and cannot be: the server cannot read
+ * localStorage, so `sidebarBootScript` stamps `html[data-sidebar]` before first
+ * paint and the stylesheet lets that attribute win. The class is what keeps
+ * React's view in sync afterwards.
  *
- * Three wikis had hand-rendered the same tree with the same `wiki-rail__*`
- * classes and then drifted on the details — one lost the scroll wrapper, one
- * labelled neither `<nav>`, one appended the sections above the contents. The
- * class names are NOT props: they are the shared convention the three
- * stylesheets already implement, and making them configurable would only let
- * that convention fork again. Every string a reader sees is a prop, because
- * those genuinely differ.
+ * Closing on navigate is scoped to mobile because that is where the rail
+ * OVERLAYS the article — on a desktop it is a column beside it, and collapsing
+ * it on every click would be a rail that folds itself away as you use it.
+ */
+export declare function RailShell({ children, prefix, label, className }: RailShellProps): import("react").JSX.Element;
+/**
+ * Is this rail link the one the reader is on?
  *
- * Sections only, never the pages under them. The front page lists every page
- * under each section and a section page lists its own; mirroring that here
- * would make the rail a second copy of what is on screen.
+ * `tree` marks a link that owns its descendants — a section that should stay lit
+ * while you read a page inside it. Both rails had this predicate and both
+ * matched on the PATH ONLY, deliberately: `?edit=` and `?history=` are modes a
+ * page enters, not destinations a rail selects, and reading them would drag
+ * `useSearchParams` into a statically-rendered wiki.
  */
-export declare function WikiRail({ link: Link, activePath, homeHref, sections, headings, label, toggleLabel, homeLabel, homeGlyph, sectionsLabel, tocLabel, }: WikiRailProps): import("react").JSX.Element;
+export declare function isRailLinkActive(activePath: string, href: string, tree?: boolean): boolean;
 export type { WikiLinkComponent, WikiLinkProps } from './react-server.js';
-//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -574,30 +574,51 @@ export class ErrorBoundary extends Component {
     }
 }
 /**
- * The persistent left rail: home, table of contents, sections.
+ * The collapsible rail's outer shell: the landmark, its three states, and the
+ * scroll container, with a tap inside it closing the rail on mobile.
  *
- * Three wikis had hand-rendered the same tree with the same `wiki-rail__*`
- * classes and then drifted on the details — one lost the scroll wrapper, one
- * labelled neither `<nav>`, one appended the sections above the contents. The
- * class names are NOT props: they are the shared convention the three
- * stylesheets already implement, and making them configurable would only let
- * that convention fork again. Every string a reader sees is a prop, because
- * those genuinely differ.
+ * THE THREE STATES ARE NOT TWO. `--open` / `--closed` is the reader's choice;
+ * `--instant` suppresses the transition until that choice has been read out of
+ * storage. Without the third, a rail the reader left closed renders open and
+ * then *slides shut* on every single load — and because the fix is invisible
+ * once it works, it is the part a reimplementation drops. Both rails that had
+ * this written out locally carried the same paragraph of comment explaining it,
+ * which is how you can tell it was learned twice.
  *
- * Sections only, never the pages under them. The front page lists every page
- * under each section and a section page lists its own; mirroring that here
- * would make the rail a second copy of what is on screen.
+ * The class is not authoritative and cannot be: the server cannot read
+ * localStorage, so `sidebarBootScript` stamps `html[data-sidebar]` before first
+ * paint and the stylesheet lets that attribute win. The class is what keeps
+ * React's view in sync afterwards.
+ *
+ * Closing on navigate is scoped to mobile because that is where the rail
+ * OVERLAYS the article — on a desktop it is a column beside it, and collapsing
+ * it on every click would be a rail that folds itself away as you use it.
+ */
+export function RailShell({ children, prefix, label, className }) {
+    const { open, setOpen, isMobile, ready } = useSidebar();
+    const close = useCallback(() => {
+        if (isMobile)
+            setOpen(false);
+    }, [isMobile, setOpen]);
+    const classes = [
+        prefix,
+        open ? `${prefix}--open` : `${prefix}--closed`,
+        ready ? '' : `${prefix}--instant`,
+        className ?? '',
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return (_jsx("aside", { className: classes, "aria-label": label, children: _jsx("div", { className: `${prefix}__scroll`, onClick: close, children: children }) }));
+}
+/**
+ * Is this rail link the one the reader is on?
+ *
+ * `tree` marks a link that owns its descendants — a section that should stay lit
+ * while you read a page inside it. Both rails had this predicate and both
+ * matched on the PATH ONLY, deliberately: `?edit=` and `?history=` are modes a
+ * page enters, not destinations a rail selects, and reading them would drag
+ * `useSearchParams` into a statically-rendered wiki.
  */
-export function WikiRail({ link: Link, activePath, homeHref, sections, headings = [], label = 'Wiki', toggleLabel = 'Wiki menu', homeLabel = 'Wiki home', homeGlyph = '📖', sectionsLabel = 'Sections', tocLabel = 'On this page', }) {
-    const { open, toggle } = useSidebar();
-    const item = (href, active) => `wiki-rail__item${active ? ' wiki-rail__item--active' : ''}`;
-    return (_jsxs("aside", { className: "wiki-sidebar", "aria-label": label, children: [_jsxs("button", { type: "button", className: "wiki-rail__toggle", onClick: toggle, "aria-expanded": open, children: [_jsx("span", { className: "wiki-rail__glyph", "aria-hidden": true, children: open ? '▾' : '▸' }), toggleLabel] }), _jsxs("div", { className: "wiki-rail__scroll", children: [_jsx("nav", { className: "wiki-rail__group", children: _jsxs(Link, { href: homeHref, className: item(homeHref, activePath === homeHref), children: [_jsx("span", { className: "wiki-rail__glyph", "aria-hidden": true, children: homeGlyph }), homeLabel] }) }), _jsx(TableOfContents, { headings: headings.map(h => ({ id: h.id, text: h.text, level: h.level })), indentRem: 0, offsetVar: "--spacing-lg", offsetFallback: 24, classNames: {
-                            root: 'wiki-rail__group wiki-rail__group--toc',
-                            button: 'wiki-rail__toc-btn',
-                            label: 'wiki-rail__label',
-                            list: 'wiki-rail__toc-list',
-                            item: 'wiki-rail__toc-item',
-                            itemActive: 'wiki-rail__toc-item--active',
-                        }, label: tocLabel }), _jsxs("nav", { className: "wiki-rail__group", "aria-label": sectionsLabel, children: [_jsx("span", { className: "wiki-rail__label", children: sectionsLabel }), sections.map(section => (_jsxs(Link, { href: section.href, title: section.blurb, className: item(section.href, activePath === section.href || activePath.startsWith(`${section.href}/`)), children: [_jsx("span", { className: "wiki-rail__glyph", "aria-hidden": true, children: section.glyph }), section.title] }, section.href)))] })] })] }));
+export function isRailLinkActive(activePath, href, tree = false) {
+    return tree ? activePath === href || activePath.startsWith(`${href}/`) : activePath === href;
 }
-//# sourceMappingURL=react.js.map

package/dist/revisions.d.ts

@@ -96,4 +96,3 @@ export declare function computeRevisionDiff<B extends DiffBlock, L = unknown>(op
     leafDiff?: DiffOptions<B, L>['leafDiff'];
 }): RevisionDiff<L>;
 export {};
-//# sourceMappingURL=revisions.d.ts.map

package/dist/revisions.js

@@ -170,4 +170,3 @@ export function computeRevisionDiff(opts) {
     };
     return { ...partial, summary: changeSummary({ ...partial, metaLabel: opts.metaLabel }) };
 }
-//# sourceMappingURL=revisions.js.map

package/dist/rola.d.ts

@@ -125,4 +125,3 @@ export interface RolaAuth {
     }>;
 }
 export declare function createRolaAuth(config: RolaAuthConfig): RolaAuth;
-//# sourceMappingURL=rola.d.ts.map

package/dist/rola.js

@@ -147,4 +147,3 @@ export function createRolaAuth(config) {
         },
     };
 }
-//# sourceMappingURL=rola.js.map

package/dist/seeded.d.ts

@@ -0,0 +1,11 @@
+/** djb2-ish, 32-bit, non-negative. Stable across processes and runtimes. */
+export declare function hashStr(s: string): number;
+/**
+ * Lehmer/Park-Miller, seeded by an integer.
+ *
+ * Both guards matter and neither is obvious. Without the modulo a seed can
+ * exceed the modulus; without the `<= 0` correction a seed of 0 sticks the
+ * generator at 0 forever — every call returns the same number and whatever it
+ * was laying out degenerates to a single point.
+ */
+export declare function seededRandom(seed: number): () => number;

package/dist/seeded.js

@@ -0,0 +1,32 @@
+// seeded.ts — deterministic pseudo-randomness, for art that must not move.
+//
+// Both wikis generate SVG from a title: a page banner, a fallback icon. The
+// mark has to be identical on the server and in the browser and on the next
+// render forever, so `Math.random` is not available to them and these two are
+// what they use instead. Both had written the same pair, and the comment in one
+// of them recorded that its two guards had been ported from the other — which
+// is a copy documenting itself as a copy.
+/** djb2-ish, 32-bit, non-negative. Stable across processes and runtimes. */
+export function hashStr(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++)
+        h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+    return Math.abs(h);
+}
+/**
+ * Lehmer/Park-Miller, seeded by an integer.
+ *
+ * Both guards matter and neither is obvious. Without the modulo a seed can
+ * exceed the modulus; without the `<= 0` correction a seed of 0 sticks the
+ * generator at 0 forever — every call returns the same number and whatever it
+ * was laying out degenerates to a single point.
+ */
+export function seededRandom(seed) {
+    let s = seed % 2147483647;
+    if (s <= 0)
+        s += 2147483646;
+    return () => {
+        s = (s * 16807) % 2147483647;
+        return s / 2147483647;
+    };
+}

package/dist/sidebar.d.ts

@@ -35,4 +35,3 @@ export declare const SIDEBAR_ATTRIBUTE = "data-sidebar";
  * dies before it paints.
  */
 export declare function sidebarBootScript(storageKey?: string, breakpoint?: number): string;
-//# sourceMappingURL=sidebar.d.ts.map

package/dist/sidebar.js

@@ -40,4 +40,3 @@ export function sidebarBootScript(storageKey = 'wiki:sidebar', breakpoint = 1024
         `var o=v===null?!window.matchMedia("(max-width: ${breakpoint - 1}px)").matches:v==="1";` +
         `document.documentElement.setAttribute(${JSON.stringify(SIDEBAR_ATTRIBUTE)},o?"open":"closed");}catch(e){}})()`);
 }
-//# sourceMappingURL=sidebar.js.map

package/dist/taxonomy.d.ts

@@ -161,4 +161,3 @@ export interface Taxonomy {
     rankRelated: <T extends FacetablePage>(page: T, siblings: T[], tagPath: string, limit?: number) => RelatedRanking<T>;
 }
 export declare function createTaxonomy(config: TaxonomyConfig): Taxonomy;
-//# sourceMappingURL=taxonomy.d.ts.map

package/dist/taxonomy.js

@@ -235,4 +235,3 @@ export function createTaxonomy(config) {
         },
     };
 }
-//# sourceMappingURL=taxonomy.js.map

package/dist/text.d.ts

@@ -13,6 +13,20 @@ export type BannerVariant = 'stub' | 'unsourced' | 'outdated' | 'promotional' |
  * the markdown twin and the MDX export all render the same six strings.
  */
 export declare const BANNER_LABELS: Record<BannerVariant, string>;
+/**
+ * The banner variants as an editor's option list, in the order a writer meets
+ * them: the two that describe a gap first, then the three that describe a flaw.
+ *
+ * Derived from `BANNER_LABELS` rather than restated. Both editors had typed the
+ * same six `{ value, label }` pairs out by hand, which made four places in the
+ * workspace holding the same strings — and an editor whose dropdown disagrees
+ * with the renderer's label is a page whose banner changes wording when you
+ * open it for editing.
+ */
+export declare const BANNER_VARIANTS: ReadonlyArray<{
+    value: BannerVariant;
+    label: string;
+}>;
 /** 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. */
@@ -38,4 +52,3 @@ export declare function collectText(node: unknown, out?: string[]): string[];
  * than a failure: title-only hits are how the top tiers match.
  */
 export declare function matchSnippet(blocks: unknown, query: string, opening: () => string, maxLen?: number): string;
-//# sourceMappingURL=text.d.ts.map

package/dist/text.js

@@ -7,7 +7,7 @@
 // As in `blocks.ts`, the dispatch stays with the caller — a `switch` over its
 // own block union, where a new type is a compile error until it is handled —
 // and only the bodies live here.
-import { decodeEntities } from './entities.js';
+import { decodeEntities } from './markdown.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
@@ -36,6 +36,20 @@ export const BANNER_LABELS = {
     cleanup: 'Needs cleanup',
     coi: 'Conflict of interest',
 };
+/**
+ * The banner variants as an editor's option list, in the order a writer meets
+ * them: the two that describe a gap first, then the three that describe a flaw.
+ *
+ * Derived from `BANNER_LABELS` rather than restated. Both editors had typed the
+ * same six `{ value, label }` pairs out by hand, which made four places in the
+ * workspace holding the same strings — and an editor whose dropdown disagrees
+ * with the renderer's label is a page whose banner changes wording when you
+ * open it for editing.
+ */
+export const BANNER_VARIANTS = Object.keys(BANNER_LABELS).map(value => ({
+    value,
+    label: BANNER_LABELS[value],
+}));
 /** A maintenance notice, inline: `[Notice: Needs citations] …`. */
 export function bannerToText(label, text) {
     return `[Notice: ${label}]${text ? ' ' + stripHtml(text) : ''}`;
@@ -109,4 +123,3 @@ export function matchSnippet(blocks, query, opening, maxLen = 200) {
     const end = Math.min(text.length, start + maxLen);
     return `${start > 0 ? '…' : ''}${text.slice(start, end).trimEnd()}${end < text.length ? '…' : ''}`;
 }
-//# sourceMappingURL=text.js.map

package/dist/tiptap.d.ts

@@ -1,5 +1,6 @@
 import { type ReactNode } from 'react';
 import { Node as TiptapNode } from '@tiptap/core';
+/** Local `cn`. Both wikis import one; the package will not depend on one. */
 export declare const Iframe: TiptapNode<any, any>;
 /** The stock extension plus the paste rule it does not ship with. */
 export declare const YouTube: TiptapNode<import("@tiptap/extension-youtube").YoutubeOptions, any>;
@@ -75,4 +76,3 @@ export declare function createTabs({ classNames, icons, tabLabel, }?: TabsOption
     TabGroup: TiptapNode<any, any>;
     TabItem: TiptapNode<any, any>;
 };
-//# sourceMappingURL=tiptap.d.ts.map

package/dist/tiptap.js

@@ -24,8 +24,8 @@ import TiptapCodeBlock from '@tiptap/extension-code-block';
 import { onTweetResize, tweetEmbedSrc } from './dom.js';
 import { toMapEmbedUrl } from './maps.js';
 import { useClickOutside } from './react.js';
+import { cx } from './html.js';
 /** Local `cn`. Both wikis import one; the package will not depend on one. */
-const cx = (...parts) => parts.filter(Boolean).join(' ');
 // ---- iframe -----------------------------------------------------------------
 export const Iframe = TiptapNode.create({
     name: 'iframe',
@@ -341,4 +341,3 @@ export function createTabs({ classNames = {}, icons = {}, tabLabel = i => `Tab $
     });
     return { TabGroup, TabItem };
 }
-//# sourceMappingURL=tiptap.js.map

package/dist/validation.d.ts

@@ -12,9 +12,9 @@ export declare function safeLinkHref(raw: string | null | undefined): string | n
 /** An author-supplied URL is fine iff it is empty (unset) or resolves safely. */
 export declare const okUrl: (u: unknown) => boolean;
 /** `[{ id, text, url? }]` — the shape a references block stores. */
-export declare function validateReferenceItems(items: unknown, urlCheck?: (u: unknown) => boolean): boolean;
+export declare function validateReferenceItems(items: unknown): boolean;
 /** `[{ id, heading, links: [{ label, href }] }]` — a link-grid block's groups. */
-export declare function validateLinkGroups(groups: unknown, urlCheck?: (u: unknown) => boolean): boolean;
+export declare function validateLinkGroups(groups: unknown): boolean;
 export interface BlockValidatorOptions {
     /** True for a type this wiki knows at all. */
     isKnownType: (type: string) => boolean;
@@ -44,4 +44,3 @@ export declare function duplicateBlockIds<B extends {
     type: string;
     id: string;
 }>(block: B, newId: () => string): B;
-//# sourceMappingURL=validation.d.ts.map