wiki-formant 0.88.0 → 0.89.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`, `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:
+The core leaves — `content`, `codeTabs`, `banner`, `references`, `stats`, `linkGrid`, `testimonial`, `events`, `locations`, `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 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.
+`wiki-formant/sanitize` is the allowlist between an author's saved HTML and a reader's browser. The block views render four HTML fields themselves — `linkGrid` descriptions, `references` and `events` text, and a place's note — 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,7 +883,7 @@ 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`, `TestimonialFields`, `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.
+The dispatch stays a `switch` over the wiki's own union, so a new type is a compile error there. `CodeTabsFields`, `StatsFields`, `TestimonialFields`, `EventsFields`, `LocationsFields`, `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.
 
@@ -891,9 +891,11 @@ A `testimonial` is `{ quote, author, role?, avatarUrl? }`, drawn by `Testimonial
 
 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 `locations` block is `{ heading?, map?, items: [{ id, name?, image?, address?, map?, phone?, email?, hours?, timeZone?, note? }] }`: where a business is and when it is open, each place with its address or its hours. `hours` are rows of `{ days, opens, closes }`, days `mon` to `sun` and times 24-hour; a closing time at or before the opening one is the next morning, and one equal to it is open all day. `LocationsView` draws `section.locations` holding `ul.places`, as many to a row as fit: each place's picture, name (an `h2`, or an `h3` under `heading`), address linked to its map (`mapHref`: the link it was given, or a search for its words), its week as grouped rows ("Mon–Fri 8am–6pm", "Sun Closed"), its note, phone and email, and with `map` an embedded map (`mapEmbed`, from a host on `DEFAULT_IFRAME_HOSTS`). Whether it is open and which row is today depend on the moment it is read, so the server draws the hours alone and the browser adds `.place-state` ("Open · closes 6pm", "Closed · opens Mon 8am") and the row's `aria-current`, by the place's own clock (`timeZone`, `DEFAULT_ZONE` `Europe/London` unset), once a minute. `wiki-formant/hours` holds those rules — `hoursRows`, `openState`, `clock`, `hoursLd` (schema.org's `OpeningHoursSpecification`), `DAYS`, `TIME`, `isZone` — for a twin, a feed or structured data. `LocationsFields` edits the places, their hours day by day; `sanitizeCoreLeaf` cleans each note. A site whose places are its own business states each as a `LocalBusiness` with `hoursLd`; a wiki describing places does not, since they are not the wiki's own. 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`, `EventsBlock`, `ListBlock`, `ColumnsBlock<A>` and `InfoboxBlock<A>`, `A` being the wiki's atomic union. `CoreLeafBlock` is every one of them but the list and the containers, as one union, and `CoreLeafType` its types. A wiki builds its atomic union from it, `CoreLeafBlock | ListBlock | its native types`, with its own `list` holding its own page rows, and derives its `BlockType` from the result. A leaf added here then reaches every wiki with the release, and fails to compile there until its label, its view and its fields are wired: a `Record` keyed by the block types is missing a key, and a switch closed with `block satisfies never` has a case left over. miow, whose union is zod's, asserts that it carries every `CoreLeafType`.
+The core blocks are `ContentBlock`, `CodeTabsBlock`, `StatsBlock`, `LinkGridBlock`, `ReferencesBlock`, `BannerBlock`, `TestimonialBlock`, `EventsBlock`, `LocationsBlock`, `ListBlock`, `ColumnsBlock<A>` and `InfoboxBlock<A>`, `A` being the wiki's atomic union. `CoreLeafBlock` is every one of them but the list and the containers, as one union, and `CoreLeafType` its types. A wiki builds its atomic union from it, `CoreLeafBlock | ListBlock | its native types`, with its own `list` holding its own page rows, and derives its `BlockType` from the result. A leaf added here then reaches every wiki with the release, and fails to compile there until its label, its view and its fields are wired: a `Record` keyed by the block types is missing a key, and a switch closed with `block satisfies never` has a case left over. miow, whose union is zod's, asserts that it carries every `CoreLeafType`.
 
 `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`.
 
@@ -1103,7 +1105,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 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.
+`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 locations block's row of places, 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

@@ -159,7 +159,8 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
    sets its photo, round, beside who said it; 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. */
+   than 30rem: a phone, or a narrow column; a locations block sets as many
+   places to a row as fit, each its picture, address, hours and map stacked. */
 .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)); }
@@ -186,6 +187,16 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
 @container (max-width: 30rem) {
   :is(.event-list, .event-list li, .event-list time) { display: block; }
 }
+.places { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 16rem), 1fr)); margin: 0; padding: 0; list-style: none; }
+.place { display: grid; align-content: start; }
+.place > :is(p, address) { margin: 0; }
+.place address { font-style: normal; white-space: pre-line; }
+.place-picture { display: block; width: 100%; aspect-ratio: 3 / 2; object-fit: cover; }
+.place-hours { width: max-content; max-width: 100%; border-collapse: collapse; }
+.place-hours :is(th, td) { border: 0; background: none; text-align: left; vertical-align: top; }
+.place-hours th { white-space: nowrap; }
+.place-contact { display: flex; flex-wrap: wrap; }
+.place-map { width: 100%; aspect-ratio: 4 / 3; max-height: 22rem; border: 0; }
 .heading-anchor,
 .ref-backlink,
 .reference-link { text-decoration: none; }
@@ -326,6 +337,22 @@ html[data-sidebar='closed'] .wiki-sidebar { width: 0; }
 }
 .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; }
 
+.locations { margin-block: 1rem; }
+.locations > h2 { margin: 0 0 1rem; }
+.place :is(h2, h3) { margin: 0 0 0.5rem; }
+.places { gap: 2rem 1.5rem; }
+.place { gap: 0.5rem; }
+.place-picture, .place-map { border-radius: var(--ui-radius); }
+.place-map { margin-top: 0.5rem; background: var(--ui-surface); }
+.place-state { font-size: 0.9em; color: var(--ui-muted); }
+.place-state[data-open] { font-weight: 600; color: inherit; }
+.place-state[data-open]::before { content: ''; display: inline-block; width: 0.5em; height: 0.5em; margin-right: 0.45em; border-radius: 50%; background: var(--ui-up); vertical-align: 0.1em; }
+.place-hours { font-variant-numeric: tabular-nums; }
+.place-hours :is(th, td) { padding: 0.15em 0; }
+.place-hours th { padding-right: 1.25em; font-weight: 400; color: var(--ui-muted); }
+.place-hours tr[aria-current] :is(th, td) { font-weight: 600; color: inherit; }
+.place-contact { gap: 0.25em 1em; }
+
 .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 EventsBlock, type InfoboxBlock, type LinkGridBlock, type ReferencesBlock, type StatsBlock, type TestimonialBlock } from './blocks.js';
+import { type BannerBlock, type CodeTabsBlock, type ColumnsBlock, type EventsBlock, type LocationsBlock, type InfoboxBlock, type LinkGridBlock, type ReferencesBlock, type StatsBlock, type TestimonialBlock } from './blocks.js';
 export interface BlockEditorClassNames {
     /** A page's block list. */
     list?: string;
@@ -182,6 +182,16 @@ export declare function EventsFields({ block, onUpdate, hint }: {
     onUpdate: (block: EventsBlock) => void;
     hint?: string;
 }): import("react").JSX.Element;
+/**
+ * Places, each with its address or its hours: its name where there are
+ * several, a picture, the address a line to a line, a map link, its hours day
+ * by day, its clock, a note and how to reach it. The page says whether each is
+ * open by its own clock.
+ */
+export declare function LocationsFields({ block, onUpdate }: {
+    block: LocationsBlock;
+    onUpdate: (block: LocationsBlock) => void;
+}): 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

@@ -25,6 +25,7 @@ import { createContext, memo, useCallback, useContext, useMemo, useState, } from
 import { BlockActions, useBlockOperations } from './react.js';
 import { CODE_LANGS, DEFAULT_LANG, EVENT_DATE, eventBegun, eventEnded, eventWhen, LIST_SOURCES, today, } from './blocks.js';
 import { BANNER_VARIANTS } from './text.js';
+import { DAY_NAMES, DAYS, DEFAULT_ZONE, hoursRows, TIME } from './hours.js';
 import { MAX_BLOCK_ROWS } from './validation.js';
 import { cx } from './html.js';
 const Context = createContext(null);
@@ -183,6 +184,27 @@ export function EventsFields({ block, onUpdate, hint }) {
                 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.' })] }));
 }
+/** A place's hours, a row for each set of days that keeps the same times, with how the week will read under them. */
+function HoursFields({ hours, onChange }) {
+    const c = useEditorContext().kit.classNames;
+    const valid = hours.filter(h => h.days.length && TIME.test(h.opens) && TIME.test(h.closes));
+    return (_jsxs("div", { className: c.stack, children: [hours.map((h, i) => (_jsxs("div", { className: c.row, children: [_jsx("span", { role: "group", "aria-label": "Days", children: DAYS.map((d, j) => (_jsxs("label", { title: DAY_NAMES[j], children: [_jsx("input", { type: "checkbox", "aria-label": DAY_NAMES[j], checked: h.days.includes(d), onChange: () => onChange(replaceAt(hours, i, { ...h, days: DAYS.filter(x => (x === d ? !h.days.includes(d) : h.days.includes(x))) })) }), DAY_NAMES[j].slice(0, 3)] }, d))) }), _jsx("input", { type: "time", "aria-label": "Opens", className: c.input, value: h.opens, onChange: e => onChange(replaceAt(hours, i, { ...h, opens: e.target.value })) }), _jsx("input", { type: "time", "aria-label": "Closes", className: c.input, value: h.closes, onChange: e => onChange(replaceAt(hours, i, { ...h, closes: e.target.value })) }), _jsx(Remove, { label: `Remove hours ${i + 1}`, onPress: () => onChange(removeAt(hours, i)) })] }, i))), _jsx(Add, { onPress: () => onChange([...hours, { days: hours.length ? [] : ['mon', 'tue', 'wed', 'thu', 'fri'], opens: '09:00', closes: '17:00' }]), children: "Add opening hours" }), valid.length > 0 && _jsx("small", { className: c.muted, children: hoursRows(valid).map(r => `${r.label} ${r.times}`).join(' · ') })] }));
+}
+/**
+ * Places, each with its address or its hours: its name where there are
+ * several, a picture, the address a line to a line, a map link, its hours day
+ * by day, its clock, a note and how to reach it. The page says whether each is
+ * open by its own clock.
+ */
+export function LocationsFields({ block, onUpdate }) {
+    const c = useEditorContext().kit.classNames;
+    const items = block.items;
+    const set = (next) => onUpdate({ ...block, items: next });
+    return (_jsxs("div", { className: c.stack, children: [_jsx(TextInput, { label: "Heading over the places (optional)", placeholder: "Our shops", optional: true, value: block.heading, onChange: heading => onUpdate({ ...block, heading }) }), items.map((p, i) => {
+                const setPlace = (patch) => set(replaceAt(items, i, { ...p, ...patch }));
+                return (_jsxs("div", { className: cx(c.nest, c.stack), children: [_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Which one (optional)", placeholder: "Covent Garden", optional: true, value: p.name, onChange: name => setPlace({ name }) }), _jsx(Remove, { label: `Remove place ${p.name || i + 1}`, onPress: () => set(removeAt(items, i)) })] }), _jsx(Field, { label: "Address, a line to a line", children: _jsx("textarea", { "aria-label": "Address", rows: 3, className: c.input, placeholder: '27 Monmouth Street\nLondon WC2H 9EU', value: p.address ?? '', onChange: e => setPlace({ address: e.target.value.trim() ? e.target.value : undefined }) }) }), _jsx(TextInput, { label: "Map link (optional)", type: "url", placeholder: "Unset, a search for the address", optional: true, value: p.map, onChange: map => setPlace({ map }) }), _jsx(HoursFields, { hours: p.hours ?? [], onChange: hours => setPlace({ hours: hours.length ? hours : undefined }) }), !!p.hours?.length && _jsx(TextInput, { label: "Time zone", placeholder: DEFAULT_ZONE, optional: true, value: p.timeZone, onChange: timeZone => setPlace({ timeZone }) }), _jsx(TextInput, { label: "What the hours do not say (optional)", placeholder: "Closed on bank holidays", optional: true, value: p.note, onChange: note => setPlace({ note }) }), _jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Phone (optional)", placeholder: "020 7232 3010", optional: true, value: p.phone, onChange: phone => setPlace({ phone }) }), _jsx(TextInput, { label: "Email (optional)", placeholder: "hello@example.com", optional: true, value: p.email, onChange: email => setPlace({ email }) })] }), _jsx(TextInput, { label: "Picture address (optional)", type: "url", placeholder: "https://", optional: true, value: p.image, onChange: image => setPlace({ image }) })] }, p.id));
+            }), _jsx(Add, { onPress: () => set([...items, { id: newId(), hours: [{ days: ['mon', 'tue', 'wed', 'thu', 'fri'], opens: '09:00', closes: '17:00' }] }]), children: "Add place" }), _jsxs("label", { children: [_jsx("input", { type: "checkbox", checked: !!block.map, onChange: e => onUpdate({ ...block, map: e.target.checked || undefined }) }), " Show a map of each address"] }), _jsx("small", { className: c.muted, children: "Readers see the days grouped, today's marked, and whether each place is open now by its own clock." })] }));
+}
 /** `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,6 @@
 import { type ImgHTMLAttributes, type ReactNode } from 'react';
-import type { CodeTab, EventItem, LinkGridGroup, ReferenceItem, ResolvedPageRef, StatItem } from './blocks.js';
+import type { CodeTab, EventItem, LinkGridGroup, PlaceItem, ReferenceItem, ResolvedPageRef, StatItem } from './blocks.js';
+import { type Hours } from './hours.js';
 import type { WikiLinkComponent } from './react-server.js';
 export interface CodeTabsViewProps {
     tabs: readonly CodeTab[];
@@ -148,6 +149,40 @@ export interface EventsViewProps {
  * reaches here through `sanitizeCoreLeaf`, as a reference's does.
  */
 export declare function EventsView({ items, upcoming, past, day }: EventsViewProps): import("react").JSX.Element;
+/**
+ * A place's week of hours, with whether it is open and today's row marked by
+ * its own clock. A cached page cannot know the moment it is read, so the
+ * server draws the hours alone and the visitor's browser says the rest.
+ */
+export declare function PlaceHours({ hours, timeZone }: {
+    hours: readonly Hours[];
+    timeZone?: string;
+}): import("react").JSX.Element;
+export interface LocationsViewProps {
+    /** An h2 over the places, whose names are then h3s; unset, each name is an h2. */
+    heading?: string | null;
+    /** A map of each address under it. */
+    map?: boolean | null;
+    /**
+     * The places. `photo` is a picture's sized `<img>` attributes, for a site
+     * with an image pipeline: data, not a function, since a server component
+     * renders this client view.
+     */
+    items: readonly (PlaceItem & {
+        id?: string;
+        photo?: Pick<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'srcSet' | 'sizes'>;
+    })[];
+}
+/**
+ * Where a business is and when it is open, as `section.locations` holding
+ * `ul.places`, a `li.place` for each: its picture (`.place-picture`), its name,
+ * its `address` (linked to its map), whether it is open now
+ * (`.place-state[data-open]`) over its week of hours (`table.place-hours`,
+ * today's row `aria-current`), its note, its phone and email
+ * (`.place-contact`) and, with `map`, an embedded map (`.place-map`). The note
+ * is written as HTML, so it reaches here through `sanitizeCoreLeaf`.
+ */
+export declare function LocationsView({ heading, map, items }: LocationsViewProps): import("react").JSX.Element;
 /**
  * A maintenance notice.
  *

package/dist/block-views.js

@@ -19,6 +19,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // HTML processor, the router's link — arrives as a prop.
 import { Fragment, useState, useSyncExternalStore } from 'react';
 import { eventBegun, eventWhen, splitEvents, today } from './blocks.js';
+import { clock, DEFAULT_ZONE, hoursRows, mapEmbed, mapHref, openState } from './hours.js';
 import { Anchor } from './react-server.js';
 import { safeLinkHref } from './validation.js';
 import { cx } from './html.js';
@@ -141,6 +142,39 @@ export function EventsView({ items, upcoming, past, day }) {
             [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) }));
 }
+// ---- locations --------------------------------------------------------------
+const everyMinute = (tick) => {
+    const timer = setInterval(tick, 60_000);
+    return () => clearInterval(timer);
+};
+/**
+ * A place's week of hours, with whether it is open and today's row marked by
+ * its own clock. A cached page cannot know the moment it is read, so the
+ * server draws the hours alone and the visitor's browser says the rest.
+ */
+export function PlaceHours({ hours, timeZone = DEFAULT_ZONE }) {
+    const now = useSyncExternalStore(everyMinute, () => clock(new Date(), timeZone).minute, () => null);
+    const state = now === null ? null : openState([...hours], now);
+    const day = now === null ? null : clock(new Date(), timeZone).day;
+    return (_jsxs(_Fragment, { children: [state && (_jsx("p", { className: "place-state", "data-open": state.open || undefined, children: state.words })), _jsx("table", { className: "place-hours", children: _jsx("tbody", { children: hoursRows([...hours]).map(r => (_jsxs("tr", { "aria-current": day && r.days.includes(day) ? 'date' : undefined, children: [_jsx("th", { scope: "row", children: r.label }), _jsx("td", { children: r.times })] }, r.label))) }) })] }));
+}
+/**
+ * Where a business is and when it is open, as `section.locations` holding
+ * `ul.places`, a `li.place` for each: its picture (`.place-picture`), its name,
+ * its `address` (linked to its map), whether it is open now
+ * (`.place-state[data-open]`) over its week of hours (`table.place-hours`,
+ * today's row `aria-current`), its note, its phone and email
+ * (`.place-contact`) and, with `map`, an embedded map (`.place-map`). The note
+ * is written as HTML, so it reaches here through `sanitizeCoreLeaf`.
+ */
+export function LocationsView({ heading, map, items }) {
+    const Name = heading ? 'h3' : 'h2';
+    return (_jsxs("section", { className: "locations", children: [heading && _jsx("h2", { children: heading }), _jsx("ul", { className: "places", children: items.map((p, i) => {
+                    const link = safeLinkHref(mapHref(p));
+                    const image = p.image && safeLinkHref(p.image);
+                    return (_jsxs("li", { className: "place", children: [image && _jsx("img", { src: image, ...p.photo, alt: "", className: "place-picture", loading: "lazy" }), p.name && _jsx(Name, { children: p.name }), p.address && _jsx("address", { children: link ? _jsx("a", { href: link, children: p.address.trim() }) : p.address.trim() }), !!p.hours?.length && _jsx(PlaceHours, { hours: p.hours, timeZone: p.timeZone }), p.note && _jsx("p", { dangerouslySetInnerHTML: { __html: p.note } }), (p.phone || p.email) && (_jsxs("p", { className: "place-contact", children: [p.phone && _jsx("a", { href: `tel:${p.phone.replace(/[^\d+]/g, '')}`, children: p.phone }), p.email && _jsx("a", { href: `mailto:${p.email}`, children: p.email })] })), map && p.address && (_jsx("iframe", { className: "place-map", src: mapEmbed({ address: p.address, map: p.map }), title: `Map of ${p.name || p.address.split('\n')[0]}`, loading: "lazy", referrerPolicy: "no-referrer-when-downgrade" }))] }, p.id ?? i));
+                }) })] }));
+}
 // ---- banner -----------------------------------------------------------------
 /**
  * A maintenance notice.

package/dist/blocks.d.ts

@@ -1,4 +1,5 @@
 import { type RelativeTimeStyle } from './freshness.js';
+import { type Hours } from './hours.js';
 import type { BlockGroup } from './revisions.js';
 import { type BannerVariant } from './text.js';
 /**
@@ -52,6 +53,24 @@ export interface EventItem {
     end?: string | null;
     text: string;
 }
+/**
+ * One place a business is: which one (`name`, where it has several), a
+ * picture, its address a line to a line, a map link, a phone, an email, its
+ * regular hours (`wiki-formant/hours`), the IANA zone its clock is in, and a
+ * line of inline HTML for what the hours do not say. It has its address or its
+ * hours, or both.
+ */
+export interface PlaceItem {
+    name?: string;
+    image?: string;
+    address?: string;
+    map?: string;
+    phone?: string;
+    email?: string;
+    hours?: Hours[];
+    timeZone?: string;
+    note?: string;
+}
 export interface LinkGridLink {
     label: string;
     href: string;
@@ -80,6 +99,9 @@ export type EditableEventItem = EventItem & {
     id: string;
     end?: string;
 };
+export type EditablePlaceItem = PlaceItem & {
+    id: string;
+};
 export interface ContentBlock {
     id: string;
     type: 'content';
@@ -132,6 +154,14 @@ export interface EventsBlock {
     items: EditableEventItem[];
     day?: string;
 }
+/** Where a business is and when it is open: `heading` an h2 over the places, whose names are then h3s, and `map` a map under each address. */
+export interface LocationsBlock {
+    id: string;
+    type: 'locations';
+    heading?: string;
+    map?: true;
+    items: EditablePlaceItem[];
+}
 /** A Wikipedia-style notice. `text` replaces the variant's standard message. */
 export interface BannerBlock {
     id: string;
@@ -147,7 +177,7 @@ export interface BannerBlock {
  * there until it is drawn, edited and labelled. The list is left out because
  * each repo resolves its `items` to its own rows.
  */
-export type CoreLeafBlock = ContentBlock | CodeTabsBlock | StatsBlock | LinkGridBlock | ReferencesBlock | BannerBlock | TestimonialBlock | EventsBlock;
+export type CoreLeafBlock = ContentBlock | CodeTabsBlock | StatsBlock | LinkGridBlock | ReferencesBlock | BannerBlock | TestimonialBlock | EventsBlock | LocationsBlock;
 export type CoreLeafType = CoreLeafBlock['type'];
 /** `A` is the wiki's atomic union: a container never holds another container. */
 export interface ColumnsBlock<A> {
@@ -313,6 +343,15 @@ export interface EventsData {
 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;
+/** The fields a locations block's text and twin read. */
+export interface LocationsData {
+    heading?: string | null;
+    items: readonly PlaceItem[];
+}
+/** Each place under its name, its hours as rows, and none of whether it is open: a twin is read at no particular moment. */
+export declare function locationsToMarkdown({ heading, items }: LocationsData): string;
+/** Each place as prose: its name, address, hours a row to a line, note, phone and email. */
+export declare function locationsToText({ heading, items }: LocationsData): string;
 /** A flat bullet list of links — resolved page lists, feed items, link rails. */
 export declare function linkList(items: readonly LinkGridLink[]): string;
 /**
@@ -354,7 +393,9 @@ export type CoreAtomicBlock<P = ResolvedPageRef> = {
     role?: string | null;
 } | ({
     type: 'events';
-} & EventsData) | {
+} & EventsData) | ({
+    type: 'locations';
+} & LocationsData) | {
     type: 'recentPages' | 'pageList';
     resolvedPages?: readonly P[] | null;
 } | {
@@ -475,6 +516,13 @@ export interface CoreBlockDefaults {
             text: string;
         }[];
     };
+    locations: () => {
+        type: 'locations';
+        items: {
+            id: string;
+            hours: Hours[];
+        }[];
+    };
 }
 /**
  * The new-block factories for the core types, which all three wikis had typed

package/dist/blocks.js

@@ -12,6 +12,7 @@
 // keeps this file free of any one repo's type union.
 import { htmlToMarkdown, inlineToMarkdown } from './markdown.js';
 import { relativeTime } from './freshness.js';
+import { hoursRows, mapHref } from './hours.js';
 import { BANNER_LABELS, bannerToText, codeTabsToText, linkGridToText, pageListToText, referencesToText, statsToText, stripHtml, testimonialToText, } from './text.js';
 // ---- the shapes the standard block types carry ------------------------------
 /**
@@ -266,6 +267,41 @@ export function eventsToText(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');
 }
+const tel = (phone) => `tel:${phone.replace(/[^\d+]/g, '')}`;
+const addressLine = (address) => address?.trim().split(/\n+/).join(', ');
+/** Each place under its name, its hours as rows, and none of whether it is open: a twin is read at no particular moment. */
+export function locationsToMarkdown({ heading, items }) {
+    const level = heading ? '###' : '##';
+    const place = (p) => {
+        const map = mapHref(p);
+        const address = addressLine(p.address);
+        return [
+            p.name && `${level} ${p.name}`,
+            p.image && `![](${p.image})`,
+            address && (map ? `[${address}](${map})` : address),
+            p.hours?.length && hoursRows(p.hours).map(r => `- ${r.label}: ${r.times}`).join('\n'),
+            p.note && inlineToMarkdown(p.note),
+            [p.phone && `[${p.phone}](${tel(p.phone)})`, p.email && `[${p.email}](mailto:${p.email})`].filter(Boolean).join(' · '),
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+    };
+    return [heading && `## ${heading}`, ...items.map(place)].filter(Boolean).join('\n\n');
+}
+/** Each place as prose: its name, address, hours a row to a line, note, phone and email. */
+export function locationsToText({ heading, items }) {
+    const place = (p) => [
+        p.name,
+        addressLine(p.address),
+        ...(p.hours?.length ? hoursRows(p.hours).map(r => `${r.label} ${r.times}`) : []),
+        p.note && stripHtml(p.note).replace(/\s+/g, ' '),
+        p.phone,
+        p.email,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return [heading, ...items.map(place)].filter(Boolean).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');
@@ -285,6 +321,7 @@ export function coreAtomicText(block) {
         case 'linkGrid': return linkGridToText(block.groups, block.intro);
         case 'testimonial': return testimonialToText(block.quote, block.author, block.role);
         case 'events': return eventsToText(block);
+        case 'locations': return locationsToText(block);
         case 'recentPages':
         case 'pageList': return pageListToText(block.resolvedPages ?? []);
         case 'list': return pageListToText(block.items ?? []);
@@ -301,6 +338,7 @@ export function coreAtomicToMarkdown(block, opts) {
         case 'linkGrid': return linkGridToMarkdown(block.groups, block.intro);
         case 'testimonial': return testimonialToMarkdown(block.quote, block.author, block.role);
         case 'events': return eventsToMarkdown(block);
+        case 'locations': return locationsToMarkdown(block);
         case 'recentPages':
         case 'pageList':
         case 'list':
@@ -345,5 +383,7 @@ export function coreBlockDefaults(opts = {}) {
         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: '' }] }),
+        // Open on weekdays, so the new place is valid before it has its address.
+        locations: () => ({ type: 'locations', items: [{ id: newId(), hours: [{ days: ['mon', 'tue', 'wed', 'thu', 'fri'], opens: '09:00', closes: '17:00' }] }] }),
     };
 }

package/dist/hours.d.ts

@@ -0,0 +1,51 @@
+export declare const DAYS: readonly ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+export type Day = (typeof DAYS)[number];
+/** Each day's whole name, as schema.org and a screen reader say it. */
+export declare const DAY_NAMES: string[];
+/** A time of day, 24-hour: "08:00", "17:30". A closing time at or before the opening one is the next morning's. */
+export declare const TIME: RegExp;
+/** Where a place's clock is when it names none. */
+export declare const DEFAULT_ZONE = "Europe/London";
+export type Hours = {
+    days: Day[];
+    opens: string;
+    closes: string;
+};
+export declare const isZone: (zone: string) => boolean;
+/**
+ * The week as rows, neighbouring days that keep the same hours set as one:
+ * "Mon–Fri 8am–6pm", "Sat 9am–4pm", "Sun Closed". `days` names each row's
+ * days, so the visitor's own day can be marked.
+ */
+export declare function hoursRows(hours: Hours[]): {
+    days: Day[];
+    label: string;
+    times: string;
+}[];
+/** The day of the week and the minute of it, by the clock at `zone`. */
+export declare function clock(now: Date, zone: string): {
+    day: "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun";
+    minute: number;
+};
+/** Whether a place is open at `minute` into its week, and the words that say so: "Open · closes 6pm", "Closed · opens Mon 8am". */
+export declare function openState(hours: Hours[], minute: number): {
+    open: boolean;
+    words: string;
+} | null;
+/** schema.org's OpeningHoursSpecification for each row of hours. */
+export declare const hoursLd: (hours: Hours[]) => {
+    '@type': string;
+    dayOfWeek: string[];
+    opens: string;
+    closes: string;
+}[];
+/** Where a place's address is on a map: the link it was given, or a search for its words. */
+export declare const mapHref: (place: {
+    address?: string;
+    map?: string;
+}) => string | undefined;
+/** A map of the place to set in the page, which needs no key: where its map link points, if that can be read, or else its address. */
+export declare const mapEmbed: (place: {
+    address: string;
+    map?: string;
+}) => string;

package/dist/hours.js

@@ -0,0 +1,114 @@
+// hours.ts — a place's opening hours: how they read, a week to a few rows, and
+// whether it is open at a given moment by its own clock. Pure, so a server
+// render, a page's twin, its structured data and the visitor's browser all
+// read them the same way. miow had them first; every app here has the
+// `locations` block now.
+import { toMapEmbedUrl } from './maps.js';
+export const DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+const NAMES = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+/** Each day's whole name, as schema.org and a screen reader say it. */
+export const DAY_NAMES = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+/** A time of day, 24-hour: "08:00", "17:30". A closing time at or before the opening one is the next morning's. */
+export const TIME = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+/** Where a place's clock is when it names none. */
+export const DEFAULT_ZONE = 'Europe/London';
+export const isZone = (zone) => {
+    try {
+        new Intl.DateTimeFormat('en-GB', { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const minutes = (t) => Number(t.slice(0, 2)) * 60 + Number(t.slice(3));
+const WEEK = 7 * 1440;
+/** "8am", "5:30pm", "noon", "midnight". */
+function timeWords(t) {
+    const m = minutes(t);
+    if (m === 0)
+        return 'midnight';
+    if (m === 720)
+        return 'noon';
+    const h = Math.floor(m / 60) % 12 || 12;
+    return `${h}${m % 60 ? `:${String(m % 60).padStart(2, '0')}` : ''}${m < 720 ? 'am' : 'pm'}`;
+}
+/** Each opening as minutes into the week from Monday's midnight, an overnight one running into the next day. */
+function spans(hours) {
+    return hours
+        .flatMap(h => h.days.map(d => {
+        const start = DAYS.indexOf(d) * 1440 + minutes(h.opens);
+        const length = (minutes(h.closes) - minutes(h.opens) + 1440) % 1440 || 1440;
+        return { start, end: start + length };
+    }))
+        .sort((a, b) => a.start - b.start);
+}
+/**
+ * The week as rows, neighbouring days that keep the same hours set as one:
+ * "Mon–Fri 8am–6pm", "Sat 9am–4pm", "Sun Closed". `days` names each row's
+ * days, so the visitor's own day can be marked.
+ */
+export function hoursRows(hours) {
+    const day = DAYS.map(d => hours
+        .filter(h => h.days.includes(d))
+        .sort((a, b) => a.opens.localeCompare(b.opens))
+        .map(h => (h.opens === h.closes ? 'Open 24 hours' : `${timeWords(h.opens)}–${timeWords(h.closes)}`))
+        .join(', '));
+    const rows = [];
+    day.forEach((times, i) => {
+        const last = rows.at(-1);
+        if (last && last.times === (times || 'Closed'))
+            last.days.push(DAYS[i]);
+        else
+            rows.push({ days: [DAYS[i]], label: '', times: times || 'Closed' });
+    });
+    for (const r of rows) {
+        const [first, last] = [DAYS.indexOf(r.days[0]), DAYS.indexOf(r.days.at(-1))];
+        r.label = r.days.length === 7 ? 'Every day' : first === last ? NAMES[first] : last === first + 1 ? `${NAMES[first]}, ${NAMES[last]}` : `${NAMES[first]}–${NAMES[last]}`;
+    }
+    return rows;
+}
+/** The day of the week and the minute of it, by the clock at `zone`. */
+export function clock(now, zone) {
+    const parts = new Intl.DateTimeFormat('en-GB', { timeZone: zone, weekday: 'short', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(now);
+    const part = (type) => parts.find(p => p.type === type)?.value ?? '';
+    const day = NAMES.indexOf(part('weekday'));
+    return { day: DAYS[day], minute: day * 1440 + Number(part('hour')) * 60 + Number(part('minute')) };
+}
+/** Whether a place is open at `minute` into its week, and the words that say so: "Open · closes 6pm", "Closed · opens Mon 8am". */
+export function openState(hours, minute) {
+    const all = spans(hours);
+    if (!all.length)
+        return null;
+    // Last week's overnight opening may still be running into this Monday, and this Sunday's into next week.
+    const runs = all.flatMap(s => [-WEEK, 0, WEEK].map(w => ({ start: s.start + w, end: s.end + w })));
+    const now = runs.find(s => s.start <= minute && minute < s.end);
+    if (now) {
+        // Openings that meet run on as one: a shop open round the clock never closes.
+        let end = now.end;
+        for (let next; (next = runs.find(s => s.start <= end && s.end > end)) && end - minute < WEEK;)
+            end = next.end;
+        if (end - minute >= WEEK)
+            return { open: true, words: 'Open 24 hours' };
+        return { open: true, words: `Open · closes ${timeWords(clockTime(end))}` };
+    }
+    const next = all.map(s => (s.start > minute ? s.start : s.start + WEEK)).sort((a, b) => a - b)[0];
+    const days = Math.floor(next / 1440) - Math.floor(minute / 1440);
+    const when = days === 0 ? '' : days === 1 ? 'tomorrow ' : `${NAMES[Math.floor(next / 1440) % 7]} `;
+    return { open: false, words: `Closed · opens ${when}${timeWords(clockTime(next))}` };
+}
+const clockTime = (minute) => {
+    const m = ((minute % 1440) + 1440) % 1440;
+    return `${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`;
+};
+/** schema.org's OpeningHoursSpecification for each row of hours. */
+export const hoursLd = (hours) => hours.map(h => ({
+    '@type': 'OpeningHoursSpecification',
+    dayOfWeek: h.days.map(d => `https://schema.org/${DAY_NAMES[DAYS.indexOf(d)]}`),
+    opens: h.opens,
+    closes: h.closes,
+}));
+/** Where a place's address is on a map: the link it was given, or a search for its words. */
+export const mapHref = (place) => place.map || (place.address ? `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(place.address.replace(/\n+/g, ', '))}` : undefined);
+/** A map of the place to set in the page, which needs no key: where its map link points, if that can be read, or else its address. */
+export const mapEmbed = (place) => (place.map && toMapEmbedUrl(place.map)) || `https://maps.google.com/maps?q=${encodeURIComponent(place.address.replace(/\n+/g, ', '))}&z=15&output=embed`;

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` and `events` item text. Every other field those blocks
+ * descriptions, `references` and `events` item text, and a place's note. 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` and `events` item text. Every other field those blocks
+ * descriptions, `references` and `events` item text, and a place's note. 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
@@ -179,6 +179,8 @@ export function sanitizeCoreLeaf(block, clean) {
         case 'references':
         case 'events':
             return { ...b, items: each(b.items, i => (str(i.text) ? { ...i, text: clean(i.text) } : i)) };
+        case 'locations':
+            return { ...b, items: each(b.items, p => (str(p.note) ? { ...p, note: clean(p.note) } : p)) };
         default:
             return block;
     }

package/dist/validation.js

@@ -9,6 +9,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, EVENT_DATE, eventEndsBefore, LIST_SOURCES } from './blocks.js';
+import { DAYS, isZone, TIME } from './hours.js';
 /**
  * An href acceptable to persist: http, https, mailto, tel, or a relative path or
  * fragment. Everything else — `javascript:`, `data:`, `vbscript:`, a
@@ -88,6 +89,31 @@ export function validateEventItems(items) {
             (e.end === undefined || (typeof e.end === 'string' && EVENT_DATE.test(e.end))) &&
             !eventEndsBefore(e)));
 }
+/** `[{ days, opens, closes }]` — a place's regular hours, each row one day or more and two times of day. @internal */
+export function validateHours(hours) {
+    return (Array.isArray(hours) &&
+        hours.length <= 21 &&
+        hours.every(h => isRecord(h) &&
+            Array.isArray(h.days) &&
+            h.days.length > 0 &&
+            h.days.every(d => DAYS.includes(d)) &&
+            typeof h.opens === 'string' &&
+            TIME.test(h.opens) &&
+            typeof h.closes === 'string' &&
+            TIME.test(h.closes)));
+}
+/** `[{ id, name?, image?, address?, map?, phone?, email?, hours?, timeZone?, note? }]` — a locations block's places, each with its address or its hours. @internal */
+export function validatePlaces(items) {
+    return (Array.isArray(items) &&
+        items.every(p => isRecord(p) &&
+            typeof p.id === 'string' &&
+            [p.name, p.address, p.phone, p.email, p.note].every(optionalString) &&
+            (p.image === undefined || okUrl(p.image)) &&
+            (p.map === undefined || okUrl(p.map)) &&
+            (p.hours === undefined || validateHours(p.hours)) &&
+            (p.timeZone === undefined || (typeof p.timeZone === 'string' && isZone(p.timeZone))) &&
+            (!!p.address?.trim() || (Array.isArray(p.hours) && p.hours.length > 0))));
+}
 // ---- the core leaf set ------------------------------------------------------
 /**
  * The most rows an author-supplied count may ask for. Every `limit` and every
@@ -146,6 +172,8 @@ export function coreAtomicValidator(opts = {}) {
                 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);
+            case 'locations':
+                return optionalString(b.heading) && (b.map === undefined || b.map === true) && validatePlaces(b.items);
             default:
                 return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.88.0",
+  "version": "0.89.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",
@@ -172,6 +172,11 @@
       "import": "./dist/freshness.js",
       "default": "./dist/freshness.js"
     },
+    "./hours": {
+      "types": "./dist/hours.d.ts",
+      "import": "./dist/hours.js",
+      "default": "./dist/hours.js"
+    },
     "./text": {
       "types": "./dist/text.d.ts",
       "import": "./dist/text.js",