wiki-formant 0.86.3 → 0.87.0

package/README.md

@@ -728,7 +728,7 @@ leafBlocks(blocks, BLOCK_SHAPE.containers);
 
 The dispatch over a repo's own block union stays in that repo; the bodies come from here. `coreAtomicText` has a prose body for every core leaf — the stats, link-grid and page-list bodies joined the originals when two of the three wikis turned out to extract nothing from them, so their MCP `get_page` answered a hub page as nearly empty.
 
-The core leaves — `content`, `codeTabs`, `banner`, `references`, `stats`, `linkGrid`, `testimonial`, `recentPages`, `pageList`, and `list`, which does what the two page lists do between them — had the same case bodies in every wiki's text export, markdown twin, validator and new-block record. A repo's switch hands those cases over and keeps its own, so it stays exhaustive over its union:
+The core leaves — `content`, `codeTabs`, `banner`, `references`, `stats`, `linkGrid`, `testimonial`, `events`, `recentPages`, `pageList`, and `list`, which does what the two page lists do between them — had the same case bodies in every wiki's text export, markdown twin, validator and new-block record. A repo's switch hands those cases over and keeps its own, so it stays exhaustive over its union:
 
 ```ts
 import { coreAtomicText, coreAtomicToMarkdown, coreBlockDefaults } from 'wiki-formant/blocks';
@@ -782,7 +782,7 @@ A `codeTabs` tab's `code` is source text in every wiki here, and every view trea
 
 ## Sanitising stored HTML
 
-`wiki-formant/sanitize` is the allowlist between an author's saved HTML and a reader's browser. The block views render two HTML fields themselves — `linkGrid` descriptions and `references` text — and a repo renders `content.text` beside them, so the guard ships with the renderer. `codeTabs` is not one of them: its code is source. Run it server-side, on the render path, so it covers rows written before it existed and no sanitiser ships to the client.
+`wiki-formant/sanitize` is the allowlist between an author's saved HTML and a reader's browser. The block views render three HTML fields themselves — `linkGrid` descriptions, and `references` and `events` text — and a repo renders `content.text` beside them, so the guard ships with the renderer. `codeTabs` is not one of them: its code is source. Run it server-side, on the render path, so it covers rows written before it existed and no sanitiser ships to the client.
 
 ```ts
 import { createHtmlSanitizer, sanitizeCoreLeaf } from 'wiki-formant/sanitize';
@@ -883,15 +883,17 @@ const SCHEMA: BlockSchema<Block> = {
 <BlockEditor blocks={blocks} onChange={setBlocks} schema={SCHEMA} kit={KIT} />
 ```
 
-The dispatch stays a `switch` over the wiki's own union, so a new type is a compile error there. `CodeTabsFields`, `StatsFields`, `ReferencesFields`, `LinkGridFields`, `BannerFields`, `PageListFields`, `ListFields`, `ColumnsFields` and `InfoboxFields` take the core blocks `wiki-formant/blocks` declares; the two containers hold the same list, offering `nestedTypes`. `Field`, `Choice` and `LimitField` are exported for a wiki's own editors, so its native types wear the same kit. A card is marked `data-selected` while it is being edited and `data-nested` inside a container; a type the build does not know is shown by its raw type and carried through untouched. Keep the kit and the schema stable — a module constant or a `useMemo` — since both reach every card through context, and a fresh one re-renders every card on every keystroke.
+The dispatch stays a `switch` over the wiki's own union, so a new type is a compile error there. `CodeTabsFields`, `StatsFields`, `EventsFields`, `ReferencesFields`, `LinkGridFields`, `BannerFields`, `PageListFields`, `ListFields`, `ColumnsFields` and `InfoboxFields` take the core blocks `wiki-formant/blocks` declares; the two containers hold the same list, offering `nestedTypes`. `Field`, `Choice` and `LimitField` are exported for a wiki's own editors, so its native types wear the same kit. A card is marked `data-selected` while it is being edited and `data-nested` inside a container; a type the build does not know is shown by its raw type and carried through untouched. Keep the kit and the schema stable — a module constant or a `useMemo` — since both reach every card through context, and a fresh one re-renders every card on every keystroke.
 
 An editor that draws each block in place, with a list of its own (miow's), hosts the same fields in `<BlockFieldsKit kit={KIT}>`, without `<BlockEditor>`. Only the two container fields need the full editor, since they hold a block list.
 
 A `testimonial` is `{ quote, author, role?, avatarUrl? }`, drawn by `TestimonialView` as `figure.testimonial`: the words in a `blockquote`, then a `figcaption` holding the photo and a `span` of `strong` (who) and `small` (their role). radix-wiki and miow each had one under its own field names; a site with sized images passes `photo`, the `<img>` attributes (`src`, `srcSet`, `sizes`) it made from `avatarUrl`. They are data, because a server component renders the view.
 
+An `events` block is `{ upcoming?, past?, items: [{ id, date, end?, text }] }`: exhibitions, shows, talks, each dated as precisely as it is known (`EVENT_DATE`: `2026`, `2026-11` or `2026-11-12`), its end no earlier than its start, and its `text` inline HTML saying what and where. The items are stored in any order. `EventsView` sets those to come or on now soonest first under `upcoming` ("Upcoming"), with "Now on" beside one that has begun, and those that have ended latest first under `past` ("Past"), as `section.events` holding an `h2` and an `ol.event-list` for each; `base.css` gives every row's dates one column, shared by both lists. A date compares at its own precision, so `2026-08` is on until August ends. The page is split twice: by `day`, the day it was rendered (`today()` on the server), and again in the browser by the visitor's own day, because a cached page can be a day old and a show that closed since then is past. A wiki whose renderer is a client component fills `day` on the server when the page is read (it is never stored), so hydration matches what the server drew. `splitEvents`, `eventWhen` ("12 – 18 Nov 2026"), `eventBegun`, `eventEnded` and `eventEndsBefore` are the same rules for a twin, a feed or an editor; `coreAtomicText` and `coreAtomicToMarkdown` split by `day` too. `EventsFields` edits the rows in the order they were written, each with how its dates read and where the page sets it today, and `sanitizeCoreLeaf` cleans each event's text. miow had it first.
+
 A banner with no text of its own shows `BANNER_MESSAGES` from `wiki-formant/text`, a sentence per variant that names no wiki; `BannerView` takes it unless `message` overrides it.
 
-The core blocks are `ContentBlock`, `CodeTabsBlock`, `StatsBlock`, `LinkGridBlock`, `ReferencesBlock`, `BannerBlock`, `TestimonialBlock`, `ListBlock`, `ColumnsBlock<A>` and `InfoboxBlock<A>`, `A` being the wiki's atomic union. A wiki builds its union from them beside its own `recentPages` and `pageList`, which hold its own page rows or a section, and its native types.
+The core blocks are `ContentBlock`, `CodeTabsBlock`, `StatsBlock`, `LinkGridBlock`, `ReferencesBlock`, `BannerBlock`, `TestimonialBlock`, `EventsBlock`, `ListBlock`, `ColumnsBlock<A>` and `InfoboxBlock<A>`, `A` being the wiki's atomic union. A wiki builds its union from them beside its own `recentPages` and `pageList`, which hold its own page rows or a section, and its native types.
 
 `ListBlock` is one list of the wiki's pages where those two were two: the pages in a section (`source: 'under'`), the newest, in a section or across the wiki (`'newest'`, `count`), or pages picked by hand (`'chosen'`, `pages`, keyed as the wiki keys a page, an id or a path), shown as links with their age or as cards (`show`). A wiki resolves it to `items` as it does a page list. `ListFields` edits it, with `pages` to pick from and `sections` to name; a wiki with a source of its own, a shop's products say, passes it in `sources` and draws its fields as `children`.
 
@@ -1101,7 +1103,7 @@ the site's stylesheet gives them and the box a look.
 
 ## Base stylesheet
 
-`wiki-formant/base.css` is the layout the package's markup does not work without, and nothing else: columns that stack until there is room, stored tab panels that show one at a time, a copy button pinned to its block's corner and visible on focus and on touch, a table's scroll box, the stats block's grid, the code-tab strip, the banner's row and the infobox's wrapping, the breadcrumb row, the `aria-sort` arrow as a mask over `currentColor`, the stats page's grid and bars, and the chart's height and pinned buttons. It also carries the shape and motion of the primitives every site re-implemented and forked — `.spinner` (a `currentColor` ring sized by `--spinner-size`), `.skeleton`'s pulse, `.empty-state`, the wrap rule for long tokens in inline `code` — and the reduced-motion guard none of them had. No colour and no scale, so a design system's own rules override it at equal specificity. The one set of tokens it declares is the page frame every site lays out by: `--content-width` (72rem, gutters inside), `--sidebar-width` (18rem) and `--page-pad` (16 / 24 / 32px at base / 640 / 1024). They sit in the components layer, so a site never restates them in `@theme`, which would lose; an element that must differ sets its own.
+`wiki-formant/base.css` is the layout the package's markup does not work without, and nothing else: columns that stack until there is room, stored tab panels that show one at a time, a copy button pinned to its block's corner and visible on focus and on touch, a table's scroll box, the stats block's grid, the events block's shared date column, the code-tab strip, the banner's row and the infobox's wrapping, the breadcrumb row, the `aria-sort` arrow as a mask over `currentColor`, the stats page's grid and bars, and the chart's height and pinned buttons. It also carries the shape and motion of the primitives every site re-implemented and forked — `.spinner` (a `currentColor` ring sized by `--spinner-size`), `.skeleton`'s pulse, `.empty-state`, the wrap rule for long tokens in inline `code` — and the reduced-motion guard none of them had. No colour and no scale, so a design system's own rules override it at equal specificity. The one set of tokens it declares is the page frame every site lays out by: `--content-width` (72rem, gutters inside), `--sidebar-width` (18rem) and `--page-pad` (16 / 24 / 32px at base / 640 / 1024). They sit in the components layer, so a site never restates them in `@theme`, which would lose; an element that must differ sets its own.
 
 ```css
 @import "wiki-formant/base.css" layer(components);

package/dist/base.css

@@ -155,7 +155,10 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
    The structure three or four sites had each restated around this markup;
    padding, gaps, radii and colour stay theirs. A stats block is two columns,
    three or four from 40rem; a code-tab strip is a row of buttons; a banner sets
-   its icon beside its text; a long address in an infobox wraps. */
+   its icon beside its text; a long address in an infobox wraps; an events
+   block sets every row's dates in one column, shared by Upcoming and Past
+   through a subgrid, and stacks them over the words wherever it is narrower
+   than 30rem: a phone, or a narrow column. */
 .stat-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); }
 @media (min-width: 40rem) {
   .stat-grid-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
@@ -171,6 +174,14 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
    sits outside the article's prose box, and on radix.wiki ran 709px. */
 .link-grid-group-description { max-width: var(--measure); }
 .infobox-series { display: flex; flex-direction: column; }
+.events { display: grid; grid-template-columns: auto 1fr; container-type: inline-size; }
+.events > *, .event-list li { grid-column: 1 / -1; }
+.event-list, .event-list li { display: grid; grid-template-columns: subgrid; }
+.event-list { margin: 0; padding: 0; list-style: none; }
+.event-list time { white-space: nowrap; }
+@container (max-width: 30rem) {
+  :is(.event-list, .event-list li, .event-list time) { display: block; }
+}
 .heading-anchor,
 .ref-backlink,
 .reference-link { text-decoration: none; }
@@ -297,6 +308,16 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
 
 .facet-summary { margin: 0; font-size: var(--ui-small); color: var(--ui-muted); }
 
+.events { column-gap: 1rem; margin-block: 1rem; }
+.events h2 { margin: 0 0 1rem; }
+.events ol ~ h2 { margin-top: 2.5rem; }
+.event-list { row-gap: 0.75rem; }
+.event-list time { color: var(--ui-muted); font-variant-numeric: tabular-nums; }
+@container (max-width: 30rem) {
+  .event-list li + li { margin-top: 0.75rem; }
+}
+.event-now { margin-left: 0.5em; padding: 0.1em 0.55em; border-radius: 999px; background: var(--ui-accent); color: var(--ui-on-accent); font-size: 0.8em; white-space: nowrap; }
+
 .link-grid { display: flex; flex-direction: column; gap: 1rem; margin-block: 1rem; }
 .link-grid-group-description { margin: 0 0 0.75rem; font-size: var(--ui-small); color: var(--ui-muted); }
 .link-grid-group-description p { margin: 0; }

package/dist/block-editor.d.ts

@@ -1,5 +1,5 @@
 import { type ComponentType, type ReactElement, type ReactNode } from 'react';
-import { type BannerBlock, type CodeTabsBlock, type ColumnsBlock, type InfoboxBlock, type LinkGridBlock, type ReferencesBlock, type StatsBlock } from './blocks.js';
+import { type BannerBlock, type CodeTabsBlock, type ColumnsBlock, type EventsBlock, type InfoboxBlock, type LinkGridBlock, type ReferencesBlock, type StatsBlock } from './blocks.js';
 export interface BlockEditorClassNames {
     /** A page's block list. */
     list?: string;
@@ -167,6 +167,16 @@ export declare function StatsFields({ block, onUpdate, hint }: {
     onUpdate: (block: StatsBlock) => void;
     hint?: string;
 }): import("react").JSX.Element;
+/**
+ * Events in the order they were written, each with how its dates read and
+ * where the page sets it today: the page sorts them itself, and moves each on
+ * once it ends. `text` is inline HTML, as a reference's is.
+ */
+export declare function EventsFields({ block, onUpdate, hint }: {
+    block: EventsBlock;
+    onUpdate: (block: EventsBlock) => void;
+    hint?: string;
+}): import("react").JSX.Element;
 /** `title` is the heading a references block shows when it stores none, and `noun` what one row is called. */
 export declare function ReferencesFields({ block, onUpdate, title, noun, hint, }: {
     block: ReferencesBlock;

package/dist/block-editor.js

@@ -23,7 +23,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // card re-renders on every keystroke.
 import { createContext, memo, useCallback, useContext, useMemo, useState, } from 'react';
 import { BlockActions, useBlockOperations } from './react.js';
-import { CODE_LANGS, DEFAULT_LANG, LIST_SOURCES, } from './blocks.js';
+import { CODE_LANGS, DEFAULT_LANG, EVENT_DATE, eventBegun, eventEnded, eventWhen, LIST_SOURCES, today, } from './blocks.js';
 import { BANNER_VARIANTS } from './text.js';
 import { MAX_BLOCK_ROWS } from './validation.js';
 import { cx } from './html.js';
@@ -163,6 +163,21 @@ export function StatsFields({ block, onUpdate, hint }) {
     const set = (next) => onUpdate({ ...block, items: next });
     return (_jsxs("div", { className: c.stack, children: [_jsx(Choice, { label: "Per row", value: String(block.columns), options: ['2', '3', '4'].map(n => ({ value: n, label: n })), onChange: n => onUpdate({ ...block, columns: Number(n) }) }), items.map((item, i) => (_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Figure", className: c.figure, value: item.value, onChange: value => set(replaceAt(items, i, { ...item, value: value ?? '' })) }), _jsx(TextInput, { label: "What it counts", value: item.label, onChange: label => set(replaceAt(items, i, { ...item, label: label ?? '' })) }), _jsx(Remove, { label: `Remove figure ${i + 1}`, onPress: () => set(removeAt(items, i)) })] }, item.id))), _jsx(Add, { onPress: () => set([...items, { id: newId(), value: '', label: '' }]), children: "Add figure" }), hint && _jsx("small", { className: c.muted, children: hint })] }));
 }
+/**
+ * Events in the order they were written, each with how its dates read and
+ * where the page sets it today: the page sorts them itself, and moves each on
+ * once it ends. `text` is inline HTML, as a reference's is.
+ */
+export function EventsFields({ block, onUpdate, hint }) {
+    const c = useEditorContext().kit.classNames;
+    const items = block.items;
+    const set = (next) => onUpdate({ ...block, items: next });
+    const day = today();
+    return (_jsxs("div", { className: c.stack, children: [_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Heading over those to come", placeholder: "Upcoming", optional: true, value: block.upcoming, onChange: upcoming => onUpdate({ ...block, upcoming }) }), _jsx(TextInput, { label: "Heading over those that have ended", placeholder: "Past", optional: true, value: block.past, onChange: past => onUpdate({ ...block, past }) })] }), items.map((e, i) => {
+                const dated = EVENT_DATE.test(e.date) && (!e.end || EVENT_DATE.test(e.end));
+                return (_jsxs("div", { className: c.stack, children: [_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Starts", placeholder: "Starts, e.g. 2026-11", value: e.date, onChange: date => set(replaceAt(items, i, { ...e, date: date ?? '' })) }), _jsx(TextInput, { label: "Ends (optional)", optional: true, value: e.end, onChange: end => set(replaceAt(items, i, { ...e, end })) }), _jsx(Remove, { label: `Remove event ${i + 1}`, onPress: () => set(removeAt(items, i)) })] }), _jsx(TextInput, { label: "What it is and where", placeholder: "What it is and where, e.g. Group show, Park Royal Gallery, London", value: e.text, onChange: text => set(replaceAt(items, i, { ...e, text: text ?? '' })) }), _jsx("small", { className: c.muted, children: dated ? `${eventWhen(e)} · ${eventEnded(e, day) ? 'past' : eventBegun(e, day) ? 'now on' : 'upcoming'}` : 'A year, month or day: 2026, 2026-11 or 2026-11-12' })] }, e.id));
+            }), _jsx(Add, { onPress: () => set([...items, { id: newId(), date: day.slice(0, 7), text: '' }]), children: "Add event" }), _jsx("small", { className: c.muted, children: hint ?? 'Readers see those to come soonest first and those that have ended latest first, each moving on its own once it ends.' })] }));
+}
 /** `title` is the heading a references block shows when it stores none, and `noun` what one row is called. */
 export function ReferencesFields({ block, onUpdate, title = 'References', noun = 'reference', hint, }) {
     const c = useEditorContext().kit.classNames;

package/dist/block-views.d.ts

@@ -1,5 +1,5 @@
 import { type ImgHTMLAttributes, type ReactNode } from 'react';
-import type { CodeTab, LinkGridGroup, ReferenceItem, ResolvedPageRef, StatItem } from './blocks.js';
+import type { CodeTab, EventItem, LinkGridGroup, ReferenceItem, ResolvedPageRef, StatItem } from './blocks.js';
 import type { WikiLinkComponent } from './react-server.js';
 export interface CodeTabsViewProps {
     tabs: readonly CodeTab[];
@@ -123,6 +123,31 @@ export interface TestimonialViewProps {
 }
 /** Someone's words over who said them, with their photo when there is one. */
 export declare function TestimonialView({ quote, author, role, avatarUrl, photo }: TestimonialViewProps): import("react").JSX.Element | null;
+export interface EventsViewProps {
+    items: readonly (EventItem & {
+        id?: string;
+    })[];
+    /** The heading over those to come or on now. Default `Upcoming`. */
+    upcoming?: string | null;
+    /** The heading over those that have ended. Default `Past`. */
+    past?: string | null;
+    /**
+     * The day the server split them by, `today()` where it rendered. A page is
+     * drawn by that day, so hydration matches it, then by the visitor's own: a
+     * cached page can be a day old, and a show that closed since then is past.
+     * Omitted, the server and the browser each use their own clock.
+     */
+    day?: string | null;
+}
+/**
+ * Events under two `h2`s, those to come or on now soonest first and those that
+ * have ended latest first, as `section.events` holding an `ol.event-list` under
+ * each heading. A row is the `<time>` and a `span` of the event's inline HTML,
+ * with `small.event-now` on one that has begun. `base.css` sets every row's
+ * dates in one column shared by both lists. The text is written as HTML, so it
+ * reaches here through `sanitizeCoreLeaf`, as a reference's does.
+ */
+export declare function EventsView({ items, upcoming, past, day }: EventsViewProps): import("react").JSX.Element;
 /**
  * A maintenance notice.
  *

package/dist/block-views.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // Behind its own subpath for the reason `react.tsx` is: React is an optional
 // peer, so a consumer that only wants the taxonomy or the MCP transport needs no React.
 //
-// WHY THESE FIVE AND NOT THE SWITCH. The block union is per-repo and staying
+// WHY THE LEAVES AND NOT THE SWITCH. The block union is per-repo and staying
 // that way (see the Block Model note in the workspace CLAUDE.md) — a closed
 // union is what makes `switch (block.type)` exhaustive, so a new block type is
 // a compile error rather than a silent blank. What is NOT per-repo is what a
@@ -17,7 +17,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // fork. Everything that
 // genuinely differs — the prose of a banner, whether references run through an
 // HTML processor, the router's link — arrives as a prop.
-import { Fragment, useState } from 'react';
+import { Fragment, useState, useSyncExternalStore } from 'react';
+import { eventBegun, eventWhen, splitEvents, today } from './blocks.js';
 import { Anchor } from './react-server.js';
 import { safeLinkHref } from './validation.js';
 import { cx } from './html.js';
@@ -122,6 +123,24 @@ export function TestimonialView({ quote, author, role, avatarUrl, photo }) {
     const src = avatarUrl && safeLinkHref(avatarUrl);
     return (_jsxs("figure", { className: "testimonial", children: [_jsx("blockquote", { children: quote }), _jsxs("figcaption", { children: [src && _jsx("img", { src: src, ...photo, alt: "", loading: "lazy" }), _jsxs("span", { children: [_jsx("strong", { children: author }), role && _jsx("small", { children: role })] })] })] }));
 }
+// ---- events -----------------------------------------------------------------
+const still = () => () => { };
+/**
+ * Events under two `h2`s, those to come or on now soonest first and those that
+ * have ended latest first, as `section.events` holding an `ol.event-list` under
+ * each heading. A row is the `<time>` and a `span` of the event's inline HTML,
+ * with `small.event-now` on one that has begun. `base.css` sets every row's
+ * dates in one column shared by both lists. The text is written as HTML, so it
+ * reaches here through `sanitizeCoreLeaf`, as a reference's does.
+ */
+export function EventsView({ items, upcoming, past, day }) {
+    const now = useSyncExternalStore(still, today, () => day || today());
+    const split = splitEvents(items, now);
+    return (_jsx("section", { className: "events", children: [
+            [upcoming || 'Upcoming', split.upcoming],
+            [past || 'Past', split.past],
+        ].map(([heading, rows], ended) => rows.length ? (_jsxs(Fragment, { children: [_jsx("h2", { children: heading }), _jsx("ol", { className: "event-list", children: rows.map((e, i) => (_jsxs("li", { children: [_jsx("time", { dateTime: e.date, children: eventWhen(e) }), _jsxs("span", { children: [_jsx("span", { dangerouslySetInnerHTML: { __html: e.text } }), !ended && eventBegun(e, now) && _jsx("small", { className: "event-now", children: "Now on" })] })] }, e.id ?? i))) })] }, ended)) : null) }));
+}
 // ---- banner -----------------------------------------------------------------
 /**
  * A maintenance notice.

package/dist/blocks.d.ts

@@ -42,6 +42,16 @@ export interface StatItem {
     label: string;
     suffix?: string | null;
 }
+/**
+ * An exhibition, a show, a talk: when it starts and, if later, ends, each as
+ * precisely as it is known (`EVENT_DATE`), and a line of inline HTML saying
+ * what it is and where.
+ */
+export interface EventItem {
+    date: string;
+    end?: string | null;
+    text: string;
+}
 export interface LinkGridLink {
     label: string;
     href: string;
@@ -66,6 +76,10 @@ export type EditableLinkGridGroup = LinkGridGroup & {
     id: string;
     links: LinkGridLink[];
 };
+export type EditableEventItem = EventItem & {
+    id: string;
+    end?: string;
+};
 export interface ContentBlock {
     id: string;
     type: 'content';
@@ -103,6 +117,21 @@ export interface TestimonialBlock {
     role?: string;
     avatarUrl?: string;
 }
+/**
+ * Events in any order, which the page sets under two headings by the day it is
+ * read: `upcoming` (unset, "Upcoming") over those to come or on now, `past`
+ * (unset, "Past") over those that have ended. `day` is never stored: a wiki
+ * whose renderer is a client component fills it when the page is read, with
+ * `today()` on the server, so its hydration splits the block as the server did.
+ */
+export interface EventsBlock {
+    id: string;
+    type: 'events';
+    upcoming?: string;
+    past?: string;
+    items: EditableEventItem[];
+    day?: string;
+}
 /** A Wikipedia-style notice. `text` replaces the variant's standard message. */
 export interface BannerBlock {
     id: string;
@@ -244,6 +273,36 @@ export declare function someBlock<B>(blocks: readonly B[], predicate: (block: B)
 export declare function codeTabsToMarkdown(tabs: readonly CodeTab[]): string;
 /** Metric cards as a bullet list, or `''` when empty. */
 export declare function statsToMarkdown(items: readonly StatItem[]): string;
+/** A date as precisely as it is known: a year, a month or a day (`2026`, `2026-11`, `2026-11-12`). */
+export declare const EVENT_DATE: RegExp;
+type Dated = {
+    date: string;
+    end?: string | null;
+};
+/** A day as an event's date is written, by the clock of whoever reads it: the server's, or the visitor's. */
+export declare const today: (d?: Date) => string;
+export declare const eventEnded: (e: Dated, day: string) => boolean;
+export declare const eventBegun: (e: Dated, day: string) => boolean;
+/** Whether `end` falls before `date`, at the coarser of the two. */
+export declare const eventEndsBefore: ({ date, end }: Dated) => boolean;
+/** Those still to come or on, soonest first, and those that have ended, latest first. */
+export declare function splitEvents<E extends Dated>(items: readonly E[], day: string): {
+    upcoming: E[];
+    past: E[];
+};
+/** When it is, as it reads: "Nov 2026", "12 Nov 2026", "May – Aug 2026", "12 – 18 Nov 2026". */
+export declare function eventWhen({ date, end }: Dated): string;
+/** The fields an events block's text and twin read. */
+export interface EventsData {
+    upcoming?: string | null;
+    past?: string | null;
+    items: readonly EventItem[];
+    day?: string | null;
+}
+/** Events under their headings, split by the day the twin is read, as the page is. */
+export declare function eventsToMarkdown(block: EventsData): string;
+/** Events as prose, `12 Nov 2026: Group show, London` a line, under their headings. */
+export declare function eventsToText(block: EventsData): string;
 /** A flat bullet list of links — resolved page lists, feed items, link rails. */
 export declare function linkList(items: readonly LinkGridLink[]): string;
 /**
@@ -283,7 +342,9 @@ export type CoreAtomicBlock<P = ResolvedPageRef> = {
     quote: string;
     author: string;
     role?: string | null;
-} | {
+} | ({
+    type: 'events';
+} & EventsData) | {
     type: 'recentPages' | 'pageList';
     resolvedPages?: readonly P[] | null;
 } | {
@@ -396,6 +457,14 @@ export interface CoreBlockDefaults {
         quote: string;
         author: string;
     };
+    events: () => {
+        type: 'events';
+        items: {
+            id: string;
+            date: string;
+            text: string;
+        }[];
+    };
 }
 /**
  * The new-block factories for the core types, which all three wikis had typed
@@ -409,3 +478,4 @@ export type BlockTree<A extends {
     id: string;
     type: string;
 }> = A | InfoboxBlock<A> | ColumnsBlock<A>;
+export {};

package/dist/blocks.js

@@ -203,6 +203,69 @@ export function linkGridToMarkdown(groups, intro) {
     ].join('\n'));
     return `${lead}${rendered.join('\n\n')}`;
 }
+// ---- events -----------------------------------------------------------------
+//
+// Pure, so a server render, a page's twin and the visitor's browser all split a
+// block the same way. miow had them first; every wiki here has the block now.
+/** A date as precisely as it is known: a year, a month or a day (`2026`, `2026-11`, `2026-11-12`). */
+export const EVENT_DATE = /^\d{4}(?:-(?:0[1-9]|1[0-2])(?:-(?:0[1-9]|[12]\d|3[01]))?)?$/;
+/** A day as an event's date is written, by the clock of whoever reads it: the server's, or the visitor's. */
+export const today = (d = new Date()) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+// A date compares with a day at its own precision, so "2026-08" lasts all August.
+const at = (day, when) => day.slice(0, when.length);
+const lastDay = (e) => e.end || e.date;
+export const eventEnded = (e, day) => at(day, lastDay(e)) > lastDay(e);
+export const eventBegun = (e, day) => at(day, e.date) >= e.date;
+/** Whether `end` falls before `date`, at the coarser of the two. */
+export const eventEndsBefore = ({ date, end }) => !!end && end.slice(0, date.length) < date.slice(0, end.length);
+/** Those still to come or on, soonest first, and those that have ended, latest first. */
+export function splitEvents(items, day) {
+    return {
+        upcoming: items.filter(e => !eventEnded(e, day)).sort((a, b) => a.date.localeCompare(b.date)),
+        past: items.filter(e => eventEnded(e, day)).sort((a, b) => lastDay(b).localeCompare(lastDay(a)) || b.date.localeCompare(a.date)),
+    };
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** When it is, as it reads: "Nov 2026", "12 Nov 2026", "May – Aug 2026", "12 – 18 Nov 2026". */
+export function eventWhen({ date, end }) {
+    const [y, m, d] = date.split('-');
+    const words = (s, year = true) => {
+        const [yy, mm, dd] = s.split('-');
+        return [dd && Number(dd), mm && MONTHS[Number(mm) - 1], year && yy].filter(Boolean).join(' ');
+    };
+    if (!end || end === date)
+        return words(date);
+    const [ey, em, ed] = end.split('-');
+    // The year said once where both share it, and the month too where both days fall in it.
+    if (y !== ey || !m || !em)
+        return `${words(date)} – ${words(end)}`;
+    if (m === em && d && ed)
+        return `${Number(d)} – ${words(end)}`;
+    return `${words(date, false)} – ${words(end)}`;
+}
+/** Each heading with its events, in the order the page shows them, and the day they were split by. */
+function eventSections({ upcoming, past, items, day }) {
+    const on = day || today();
+    const split = splitEvents(items, on);
+    return [
+        { heading: upcoming || 'Upcoming', items: split.upcoming, ended: false },
+        { heading: past || 'Past', items: split.past, ended: true },
+    ]
+        .filter(s => s.items.length)
+        .map(s => ({ ...s, now: (e) => !s.ended && eventBegun(e, on) }));
+}
+/** Events under their headings, split by the day the twin is read, as the page is. */
+export function eventsToMarkdown(block) {
+    return eventSections(block)
+        .map(s => `## ${s.heading}\n\n${s.items.map(e => `- ${eventWhen(e)}: ${inlineToMarkdown(e.text)}${s.now(e) ? ' (now on)' : ''}`).join('\n')}`)
+        .join('\n\n');
+}
+/** Events as prose, `12 Nov 2026: Group show, London` a line, under their headings. */
+export function eventsToText(block) {
+    return eventSections(block)
+        .map(s => `${s.heading}\n${s.items.map(e => `${eventWhen(e)}: ${stripHtml(e.text).replace(/\s+/g, ' ')}${s.now(e) ? ' (now on)' : ''}`).join('\n')}`)
+        .join('\n\n');
+}
 /** A flat bullet list of links — resolved page lists, feed items, link rails. */
 export function linkList(items) {
     return items.map(l => `- [${l.label}](${l.href})`).join('\n');
@@ -221,6 +284,7 @@ export function coreAtomicText(block) {
         case 'stats': return statsToText(block.items);
         case 'linkGrid': return linkGridToText(block.groups, block.intro);
         case 'testimonial': return testimonialToText(block.quote, block.author, block.role);
+        case 'events': return eventsToText(block);
         case 'recentPages':
         case 'pageList': return pageListToText(block.resolvedPages ?? []);
         case 'list': return pageListToText(block.items ?? []);
@@ -236,6 +300,7 @@ export function coreAtomicToMarkdown(block, opts) {
         case 'stats': return statsToMarkdown(block.items);
         case 'linkGrid': return linkGridToMarkdown(block.groups, block.intro);
         case 'testimonial': return testimonialToMarkdown(block.quote, block.author, block.role);
+        case 'events': return eventsToMarkdown(block);
         case 'recentPages':
         case 'pageList':
         case 'list':
@@ -278,5 +343,7 @@ export function coreBlockDefaults(opts = {}) {
         references: () => ({ type: 'references', title: referencesTitle, items: [] }),
         banner: () => ({ type: 'banner', variant: 'stub' }),
         testimonial: () => ({ type: 'testimonial', quote: '', author: '' }),
+        // Dated this month, so the new row is valid as it stands and reads as coming up.
+        events: () => ({ type: 'events', items: [{ id: newId(), date: today().slice(0, 7), text: '' }] }),
     };
 }

package/dist/sanitize.d.ts

@@ -22,7 +22,7 @@ export interface HtmlSanitizerOptions {
 export declare function createHtmlSanitizer(options?: HtmlSanitizerOptions): (html: string) => string;
 /**
  * The core leaf types' HTML fields, cleaned: `content.text`, `linkGrid` group
- * descriptions and `references` item text. Every other field those blocks
+ * descriptions, and `references` and `events` item text. Every other field those blocks
  * carry renders as a React text node and is escaped already.
  *
  * Returns any other block untouched, so it drops straight into a

package/dist/sanitize.js

@@ -157,7 +157,7 @@ const each = (v, map) => Array.isArray(v) ? v.map(item => (item && typeof item =
 const str = (v) => typeof v === 'string';
 /**
  * The core leaf types' HTML fields, cleaned: `content.text`, `linkGrid` group
- * descriptions and `references` item text. Every other field those blocks
+ * descriptions, and `references` and `events` item text. Every other field those blocks
  * carry renders as a React text node and is escaped already.
  *
  * Returns any other block untouched, so it drops straight into a
@@ -177,6 +177,7 @@ export function sanitizeCoreLeaf(block, clean) {
                 groups: each(b.groups, g => (str(g.description) ? { ...g, description: clean(g.description) } : g)),
             };
         case 'references':
+        case 'events':
             return { ...b, items: each(b.items, i => (str(i.text) ? { ...i, text: clean(i.text) } : i)) };
         default:
             return block;

package/dist/validation.js

@@ -8,7 +8,7 @@
 //
 // As elsewhere in this package, the dispatch stays with the caller so a new
 // block type is a compile error there until it is handled.
-import { coreBlockShape, LIST_SOURCES } from './blocks.js';
+import { coreBlockShape, EVENT_DATE, eventEndsBefore, LIST_SOURCES } from './blocks.js';
 /**
  * An href acceptable to persist: http, https, mailto, tel, or a relative path or
  * fragment. Everything else — `javascript:`, `data:`, `vbscript:`, a
@@ -77,6 +77,17 @@ export function validateStatItems(items) {
             (typeof s.value === 'string' || typeof s.value === 'number') &&
             (s.suffix === undefined || s.suffix === null || typeof s.suffix === 'string')));
 }
+/** `[{ id, date, end?, text }]` — an events block's events, each dated by `EVENT_DATE` and ending no earlier than it starts. @internal */
+export function validateEventItems(items) {
+    return (Array.isArray(items) &&
+        items.every(e => isRecord(e) &&
+            typeof e.id === 'string' &&
+            typeof e.text === 'string' &&
+            typeof e.date === 'string' &&
+            EVENT_DATE.test(e.date) &&
+            (e.end === undefined || (typeof e.end === 'string' && EVENT_DATE.test(e.end))) &&
+            !eventEndsBefore(e)));
+}
 // ---- the core leaf set ------------------------------------------------------
 /**
  * The most rows an author-supplied count may ask for. Every `limit` and every
@@ -133,6 +144,8 @@ export function coreAtomicValidator(opts = {}) {
                 return validateLinkGroups(b.groups);
             case 'testimonial':
                 return typeof b.quote === 'string' && typeof b.author === 'string' && optionalString(b.role) && optionalString(b.avatarUrl);
+            case 'events':
+                return optionalString(b.upcoming) && optionalString(b.past) && validateEventItems(b.items);
             default:
                 return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.86.3",
+  "version": "0.87.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",