wiki-formant 0.50.0 → 0.52.0

package/bin/prisma-models.mjs

@@ -16,21 +16,56 @@
 //   npx prisma-models --check           # exit 1 if either is missing or differs
 //   npx prisma-models analytics         # only the ones named
 //   npx prisma-models --dir db/schema   # another folder
+//
+// An app that keeps one schema file and hand-writes the models into it, with a
+// relation the shipped ones cannot carry, checks them in place instead.
+// `--tenant` lets each model's `siteId` drop its default and gain a relation:
+//
+//   npx prisma-models analytics --check --in prisma/schema.prisma --tenant
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { arg } from './_cli.mjs';
 
 const MODELS = ['analytics', 'passkey'];
 const args = process.argv.slice(2);
 const check = args.includes('--check');
-const at = args.indexOf('--dir');
-const dir = at >= 0 ? args[at + 1] : 'prisma/schema';
-const named = args.filter((a, i) => !a.startsWith('--') && args[i - 1] !== '--dir');
+const dir = arg('--dir') ?? 'prisma/schema';
+const into = arg('--in');
+const tenant = args.includes('--tenant');
+const named = args.filter((a, i) => !a.startsWith('--') && !['--dir', '--in'].includes(args[i - 1]));
 const unknown = named.filter(n => !MODELS.includes(n));
 
-if (unknown.length || !dir) {
-  console.error(`usage: prisma-models [${MODELS.join('|')}…] [--dir <folder>] [--check]`);
+if (unknown.length || !dir || (into !== undefined && !check)) {
+  console.error(`usage: prisma-models [${MODELS.join('|')}…] [--dir <folder>] [--check [--in <schema file> [--tenant]]]`);
   process.exit(2);
 }
+
+// A model as `name → its lines`, comments, blank lines and spacing dropped.
+const models = text =>
+  new Map(
+    [...text.matchAll(/^model\s+(\w+)\s*\{[ \t]*$([\s\S]*?)^\}/gm)].map(([, name, body]) => [
+      name,
+      body
+        .split('\n')
+        .map(l => l.replace(/\/\/.*/, '').trim().replace(/\s+/g, ' '))
+        .filter(l => l && !(tenant && /^\w+ \w+ @relation\(fields: \[siteId\]/.test(l)))
+        .map(l => (tenant ? l.replace(/^siteId String @default\(""\)$/, 'siteId String') : l))
+        .join('\n'),
+    ]),
+  );
+
+if (into !== undefined) {
+  const local = models(readFileSync(into, 'utf8'));
+  let drift = 0;
+  for (const name of named.length ? named : MODELS) {
+    for (const [model, body] of models(readFileSync(new URL(`../prisma/${name}.prisma`, import.meta.url), 'utf8'))) {
+      if (local.get(model) === body) continue;
+      drift++;
+      console.error(`${into}: model ${model} ${local.has(model) ? 'differs from' : 'is missing from'} wiki-formant's prisma/${name}.prisma`);
+    }
+  }
+  process.exit(drift ? 1 : 0);
+}
 if (!existsSync(dir)) {
   console.error(`prisma-models: no ${dir}/ here. Move prisma/schema.prisma into it and point prisma.config.ts's schema at the folder.`);
   process.exit(2);

package/dist/base.css

@@ -40,6 +40,31 @@
   .columns-layout > .column-view { align-self: stretch; }
 }
 
+/* ---- layout primitives ------------------------------------------------------
+   A column, a row and a row with its ends pushed apart. radix-wiki and caper
+   wrote these with the same gaps, and acuiq2 the column; a site that meant
+   something else by a name renamed its own. The gaps are the ones all of them
+   used, so they stay here rather than going back to every stylesheet. */
+.stack, .stack-xs, .stack-sm, .stack-lg { display: flex; flex-direction: column; gap: 1rem; }
+.stack-xs { gap: 0.25rem; }
+.stack-sm { gap: 0.5rem; }
+.stack-lg { gap: 1.5rem; }
+.row, .row-xs, .row-md, .row-lg { display: flex; align-items: center; gap: 0.5rem; }
+.row-xs { gap: 0.25rem; }
+.row-md { gap: 0.75rem; }
+.row-lg { gap: 1rem; }
+.spread { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 1rem; }
+.badge { display: inline-flex; align-items: center; border-radius: 9999px; }
+
+/* A page whose first block is an infobox, one column with the infobox on top.
+   Where it splits into prose and a rail is the site's: a viewport width on one,
+   its column's width on another. Both items need `min-width: 0`, or the one
+   shared track sizes to the widest item's min-content and the other inherits
+   the overflow. */
+.page-with-infobox { display: grid; grid-template-columns: minmax(0, 1fr); grid-template-areas: "infobox" "content"; }
+.page-with-infobox > .page-main-content { grid-area: content; min-width: 0; }
+.page-with-infobox > .infobox { grid-area: infobox; min-width: 0; }
+
 /* ---- the block views and the infobox ---------------------------------------
    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,

package/dist/block-editor.d.ts

@@ -0,0 +1,203 @@
+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';
+export interface BlockEditorClassNames {
+    /** A page's block list. */
+    list?: string;
+    /** A column's or an infobox's. */
+    nestedList?: string;
+    /** The line an empty list shows. */
+    empty?: string;
+    /** A block. It carries `data-selected` while it is the one being edited, and `data-nested` inside a container. */
+    card?: string;
+    cardHead?: string;
+    cardLabel?: string;
+    cardActions?: string;
+    /** Every icon button: a card's actions, add-below, remove. */
+    action?: string;
+    /** The Add block button at the foot of a list. */
+    addBlock?: string;
+    /** The default `Add` button: Add tab, Add link. */
+    add?: string;
+    /** The default `Menu`'s wrapper and panel. */
+    menuAnchor?: string;
+    menu?: string;
+    menuItem?: string;
+    menuText?: string;
+    menuHint?: string;
+    /** A vertical group of fields. */
+    stack?: string;
+    /** A row of inputs ending in a remove button. */
+    row?: string;
+    /** A group inside a block: a link group, a column. */
+    nest?: string;
+    /** What holds the columns of a columns block. */
+    columns?: string;
+    /** The default `Field`'s label. */
+    field?: string;
+    input?: string;
+    /** Added to a code tab's language select. */
+    lang?: string;
+    /** Added to a code tab's textarea. */
+    code?: string;
+    /** Added to a stat's figure input. */
+    figure?: string;
+    /** Added to a count input. */
+    number?: string;
+    /** Row numbers, hints and notes. */
+    muted?: string;
+}
+export interface BlockEditorIcons {
+    add: ReactNode;
+    up: ReactNode;
+    down: ReactNode;
+    duplicate: ReactNode;
+    remove: ReactNode;
+}
+export interface FieldProps {
+    label: string;
+    hint?: string;
+    children: ReactNode;
+}
+/** One of a few values: a toggle group, a chip row or a select. */
+export interface ChoiceProps {
+    label: string;
+    value: string;
+    options: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    onChange: (value: string) => void;
+}
+/**
+ * The add-block menu around its trigger. `trigger` is the button the editor
+ * drew; a popover takes it as its anchor, an inline panel renders it first.
+ */
+export interface MenuProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger: ReactElement;
+    /** The icon in a block's head that adds under it, rather than the list's foot button. */
+    below: boolean;
+    children: ReactNode;
+}
+export interface AddProps {
+    onPress: () => void;
+    children: ReactNode;
+}
+export interface BlockEditorKit {
+    classNames: BlockEditorClassNames;
+    icons: BlockEditorIcons;
+    Field?: ComponentType<FieldProps>;
+    Choice?: ComponentType<ChoiceProps>;
+    Menu?: ComponentType<MenuProps>;
+    Add?: ComponentType<AddProps>;
+}
+export type EditableBlock = {
+    id: string;
+    type: string;
+};
+export interface BlockMeta {
+    label: string;
+    icon?: ReactNode;
+    /** The line under the label in the add menu. */
+    hint?: string;
+}
+export interface BlockSchema<B extends EditableBlock> {
+    /** Undefined for a type this build does not know: it is shown by its raw type and kept as it is. */
+    meta: (type: B['type']) => BlockMeta | undefined;
+    create: (type: B['type']) => B;
+    /** A copy with fresh ids at every level. */
+    duplicate: (block: B) => B;
+    /**
+     * A block's fields. The wiki's own `switch`, so it stays exhaustive over its
+     * union. Null for a type with no fields here: the card says it is kept as is.
+     */
+    renderBody: (block: B, onUpdate: (next: B) => void) => ReactNode;
+    /** What a page's add menus offer, in their order. */
+    types: readonly B['type'][];
+    /** What a column's and an infobox's offer: never a container. */
+    nestedTypes: readonly B['type'][];
+    /** Types a list holds at most one of, such as an infobox an article lifts into its rail. */
+    single?: readonly B['type'][];
+}
+export interface BlockEditorProps<B extends EditableBlock> {
+    blocks: B[];
+    onChange: (blocks: B[]) => void;
+    schema: BlockSchema<B>;
+    kit: BlockEditorKit;
+}
+/**
+ * A page's blocks, edited: each in a card with its add-below, move, duplicate
+ * and delete controls, and an add menu at the foot. Columns and infoboxes hold
+ * the same list, offering `nestedTypes`.
+ */
+export declare function BlockEditor<B extends EditableBlock>({ blocks, onChange, schema, kit }: BlockEditorProps<B>): import("react").JSX.Element;
+/** A labelled field in the kit's style, for a wiki's own block editors as well as these. */
+export declare function Field(props: FieldProps): import("react").JSX.Element;
+/** One of a few values in the kit's style; a `<select>` when the kit has none. */
+export declare function Choice(props: ChoiceProps): import("react").JSX.Element;
+/** A count clamped to 1…`MAX_BLOCK_ROWS`, the cap the write path enforces. */
+export declare function LimitField({ label, value, onChange }: {
+    label?: string;
+    value: number | undefined;
+    onChange: (n: number) => void;
+}): import("react").JSX.Element;
+/**
+ * `code` is source text, never HTML: every view escapes it. A stored language
+ * outside `langs` stays selectable rather than reading as the first option and
+ * being overwritten on the next save.
+ */
+export declare function CodeTabsFields({ block, onUpdate, langs, defaultLang, }: {
+    block: CodeTabsBlock;
+    onUpdate: (block: CodeTabsBlock) => void;
+    langs?: readonly string[];
+    defaultLang?: string;
+}): import("react").JSX.Element;
+export declare function StatsFields({ block, onUpdate, hint }: {
+    block: StatsBlock;
+    onUpdate: (block: StatsBlock) => 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;
+    onUpdate: (block: ReferencesBlock) => void;
+    title?: string;
+    noun?: string;
+    hint?: string;
+}): import("react").JSX.Element;
+export declare function LinkGridFields({ block, onUpdate }: {
+    block: LinkGridBlock;
+    onUpdate: (block: LinkGridBlock) => void;
+}): import("react").JSX.Element;
+export declare function BannerFields({ block, onUpdate }: {
+    block: BannerBlock;
+    onUpdate: (block: BannerBlock) => void;
+}): import("react").JSX.Element;
+/** A page a page list can pick. `detail` is shown after the title, such as its section. */
+export interface PageOption {
+    id: string;
+    title: string;
+    detail?: string;
+}
+/**
+ * The picked pages in their order, each movable and removable. With `pages`
+ * the rest are offered in a picker; without, an id is typed in.
+ */
+export declare function PageListFields<B extends {
+    pageIds: string[];
+}>({ block, onUpdate, pages }: {
+    block: B;
+    onUpdate: (block: B) => void;
+    pages?: readonly PageOption[];
+}): import("react").JSX.Element;
+/** Two to four columns, each a block list offering the schema's `nestedTypes`. */
+export declare function ColumnsFields<A extends EditableBlock>({ block, onUpdate }: {
+    block: ColumnsBlock<A>;
+    onUpdate: (block: ColumnsBlock<A>) => void;
+}): import("react").JSX.Element;
+/** An infobox's blocks, offering the schema's `nestedTypes`. */
+export declare function InfoboxFields<A extends EditableBlock>({ block, onUpdate }: {
+    block: InfoboxBlock<A>;
+    onUpdate: (block: InfoboxBlock<A>) => void;
+}): import("react").JSX.Element;

package/dist/block-editor.js

@@ -0,0 +1,218 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// block-editor.tsx — the block list an author edits, and the fields of the core
+// block types.
+//
+// Three wikis had written this, 500 to 700 lines each, and the copies had
+// drifted the way copies do: one dropped a stored code language that was not
+// in its list, one let a typed count run past the row cap, one named every
+// remove button "Remove", one never highlighted the block being edited. The
+// behaviour lives here once. The look does not: each wiki draws its inputs,
+// toggles and menus with its own design system, so those arrive as a KIT —
+// class names, icons, and four optional components — and the markup here is
+// bare semantic HTML wearing whatever the kit says.
+//
+// The dispatch stays with the wiki. `renderBody` is a `switch` over its own
+// closed union, as S4 of the workspace's STRUCTURE.md requires, so a new block
+// type is a compile error there; its cases hand the core types to the field
+// editors below and draw its native types themselves.
+//
+// The kit and the schema reach every nested list through context, which is
+// what lets a column or an infobox hold a list without being handed the whole
+// configuration. Keep both stable — a module constant or a `useMemo` — or every
+// 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, } from './blocks.js';
+import { BANNER_VARIANTS } from './text.js';
+import { MAX_BLOCK_ROWS } from './validation.js';
+import { cx } from './html.js';
+const Context = createContext(null);
+function useEditorContext() {
+    const ctx = useContext(Context);
+    if (!ctx)
+        throw new Error('A block field editor must render inside <BlockEditor>.');
+    return ctx;
+}
+/**
+ * A page's blocks, edited: each in a card with its add-below, move, duplicate
+ * and delete controls, and an add menu at the foot. Columns and infoboxes hold
+ * the same list, offering `nestedTypes`.
+ */
+export function BlockEditor({ blocks, onChange, schema, kit }) {
+    const value = useMemo(() => ({ kit, schema: schema }), [kit, schema]);
+    return (_jsx(Context.Provider, { value: value, children: _jsx(BlockList, { blocks: blocks, onChange: onChange }) }));
+}
+function BlockList({ blocks, onChange, nested = false }) {
+    const { kit, schema } = useEditorContext();
+    const c = kit.classNames;
+    const ops = useBlockOperations(blocks, onChange, schema);
+    const base = nested ? schema.nestedTypes : schema.types;
+    // A string, so the offer is recomputed — and every card re-rendered — only
+    // when a single-use type comes or goes, not on every keystroke.
+    const held = (schema.single ?? []).filter(t => blocks.some(b => b.type === t)).join(' ');
+    const offered = useMemo(() => base.filter(t => !held.split(' ').includes(t)), [base, held]);
+    const insertNew = useCallback((type) => ops.insert(schema.create(type)), [ops.insert, schema]);
+    return (_jsxs("div", { className: nested ? c.nestedList : c.list, children: [blocks.length === 0 && _jsx("p", { className: c.empty, children: nested ? 'Empty.' : 'Nothing here yet. Add the first block.' }), blocks.map((block, i) => (_jsx(BlockCard, { block: block, index: i, total: blocks.length, selected: ops.selectedIndex === i, nested: nested, offered: offered, update: ops.update, move: ops.move, duplicate: ops.duplicate, remove: ops.remove, insert: ops.insert, select: ops.setSelectedIndex }, block.id))), _jsx(InsertMenu, { types: offered, onPick: insertNew })] }));
+}
+// Memoised on the list's ref-stable callbacks, so a keystroke in one block does
+// not re-render every other block's editor.
+const BlockCard = memo(function BlockCard({ block, index, total, selected, nested, offered, update, move, duplicate, remove, insert, select }) {
+    const { kit, schema } = useEditorContext();
+    const c = kit.classNames;
+    const onUpdate = useCallback((next) => update(index, next), [update, index]);
+    const onSelect = useCallback(() => select(index), [select, index]);
+    const meta = schema.meta(block.type);
+    const label = meta?.label ?? block.type;
+    const body = meta ? schema.renderBody(block, onUpdate) : null;
+    return (_jsxs("section", { className: c.card, "data-selected": selected || undefined, "data-nested": nested || undefined, onFocusCapture: onSelect, onClick: onSelect, children: [_jsxs("div", { className: c.cardHead, children: [_jsxs("span", { className: c.cardLabel, children: [meta?.icon, label] }), _jsxs("span", { className: c.cardActions, children: [_jsx(InsertMenu, { below: true, types: offered, onPick: type => insert(schema.create(type), index + 1) }), _jsx(BlockActions, { index: index, total: total, ops: { move, duplicate, remove }, icons: kit.icons, className: c.cardActions, buttonClassName: c.action, blockLabel: label })] })] }), body ?? _jsx("p", { className: c.muted, children: "Kept as it is \u2013 this editor has no fields for it." })] }));
+});
+function InsertMenu({ types, onPick, below = false }) {
+    const { kit, schema } = useEditorContext();
+    const c = kit.classNames;
+    const [open, setOpen] = useState(false);
+    const Menu = kit.Menu ?? InlineMenu;
+    const toggle = () => setOpen(o => !o);
+    const trigger = below ? (_jsx("button", { type: "button", className: c.action, title: "Add a block below", "aria-label": "Add a block below", "aria-expanded": open, onClick: toggle, children: kit.icons.add })) : (_jsxs("button", { type: "button", className: c.addBlock, "aria-expanded": open, onClick: toggle, children: [kit.icons.add, "Add block"] }));
+    return (_jsx(Menu, { open: open, onOpenChange: setOpen, trigger: trigger, below: below, children: types.map(type => {
+            const meta = schema.meta(type);
+            return (_jsxs("button", { type: "button", className: c.menuItem, onClick: e => {
+                    // Inside a card, a pick is not also a click on the card.
+                    e.stopPropagation();
+                    onPick(type);
+                    setOpen(false);
+                }, children: [meta?.icon, _jsxs("span", { className: c.menuText, children: [_jsx("span", { children: meta?.label ?? type }), meta?.hint && _jsx("span", { className: c.menuHint, children: meta.hint })] })] }, type));
+        }) }));
+}
+function InlineMenu({ open, trigger, children }) {
+    const c = useEditorContext().kit.classNames;
+    return (_jsxs("span", { className: c.menuAnchor, children: [trigger, open && _jsx("span", { className: c.menu, children: children })] }));
+}
+// ---- the kit's parts, resolved ----------------------------------------------
+/** A labelled field in the kit's style, for a wiki's own block editors as well as these. */
+export function Field(props) {
+    const { Field: Custom, classNames: c } = useEditorContext().kit;
+    if (Custom)
+        return _jsx(Custom, { ...props });
+    return (_jsxs("label", { className: c.field, children: [_jsx("span", { children: props.label }), props.children, props.hint && _jsx("small", { className: c.muted, children: props.hint })] }));
+}
+/** One of a few values in the kit's style; a `<select>` when the kit has none. */
+export function Choice(props) {
+    const { Choice: Custom, classNames: c } = useEditorContext().kit;
+    if (Custom)
+        return _jsx(Custom, { ...props });
+    return (_jsx(Field, { label: props.label, children: _jsx("select", { className: c.input, value: props.value, onChange: e => props.onChange(e.target.value), children: props.options.map(o => (_jsx("option", { value: o.value, children: o.label }, o.value))) }) }));
+}
+function Add({ onPress, children }) {
+    const { Add: Custom, classNames: c, icons } = useEditorContext().kit;
+    if (Custom)
+        return _jsx(Custom, { onPress: onPress, children: children });
+    return (_jsxs("button", { type: "button", className: c.add, onClick: onPress, children: [icons.add, children] }));
+}
+function Remove({ label, onPress }) {
+    const { classNames: c, icons } = useEditorContext().kit;
+    return (_jsx("button", { type: "button", className: c.action, title: label, "aria-label": label, onClick: onPress, children: icons.remove }));
+}
+/** A text input. `optional` stores an emptied field as absent rather than `''`. */
+function TextInput({ label, value, onChange, placeholder = label, optional = false, type = 'text', className, }) {
+    const c = useEditorContext().kit.classNames;
+    return (_jsx("input", { type: type, className: cx(c.input, className), "aria-label": label, placeholder: placeholder, value: value ?? '', onChange: e => onChange(optional ? e.target.value.trim() ? e.target.value : undefined : e.target.value) }));
+}
+const replaceAt = (items, i, item) => items.map((x, j) => (j === i ? item : x));
+const removeAt = (items, i) => items.filter((_, j) => j !== i);
+const newId = () => crypto.randomUUID();
+// ---- the core blocks' fields -------------------------------------------------
+/** A count clamped to 1…`MAX_BLOCK_ROWS`, the cap the write path enforces. */
+export function LimitField({ label = 'How many', value, onChange }) {
+    const c = useEditorContext().kit.classNames;
+    return (_jsx(Field, { label: label, children: _jsx("input", { type: "number", min: 1, max: MAX_BLOCK_ROWS, className: cx(c.input, c.number), value: value ?? '', onChange: e => onChange(Math.min(MAX_BLOCK_ROWS, Math.max(1, Math.floor(Number(e.target.value)) || 1))) }) }));
+}
+/**
+ * `code` is source text, never HTML: every view escapes it. A stored language
+ * outside `langs` stays selectable rather than reading as the first option and
+ * being overwritten on the next save.
+ */
+export function CodeTabsFields({ block, onUpdate, langs = CODE_LANGS, defaultLang = DEFAULT_LANG, }) {
+    const c = useEditorContext().kit.classNames;
+    const tabs = block.tabs;
+    const set = (next) => onUpdate({ ...block, tabs: next });
+    return (_jsxs("div", { className: c.stack, children: [tabs.map((tab, i) => (_jsxs("div", { className: c.stack, children: [_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Tab label", value: tab.label, onChange: label => set(replaceAt(tabs, i, { ...tab, label: label ?? '' })) }), _jsx("select", { "aria-label": "Language", className: cx(c.input, c.lang), value: tab.language, onChange: e => set(replaceAt(tabs, i, { ...tab, language: e.target.value })), children: [...new Set([tab.language, ...langs])].map(l => (_jsx("option", { value: l, children: l }, l))) }), _jsx(Remove, { label: `Remove tab ${tab.label || i + 1}`, onPress: () => set(removeAt(tabs, i)) })] }), _jsx("textarea", { "aria-label": "Code", placeholder: "Code", rows: 6, spellCheck: false, className: cx(c.input, c.code), value: tab.code, onChange: e => set(replaceAt(tabs, i, { ...tab, code: e.target.value })) })] }, i))), _jsx(Add, { onPress: () => set([...tabs, { label: '', language: defaultLang, code: '' }]), children: "Add tab" })] }));
+}
+export function StatsFields({ block, onUpdate, hint }) {
+    const c = useEditorContext().kit.classNames;
+    const items = block.items;
+    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 })] }));
+}
+/** `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;
+    const items = block.items;
+    const set = (next) => onUpdate({ ...block, items: next });
+    return (_jsxs("div", { className: c.stack, children: [_jsx(Field, { label: "Heading", children: _jsx(TextInput, { label: "Heading", placeholder: title, optional: true, value: block.title, onChange: t => onUpdate({ ...block, title: t }) }) }), items.map((item, i) => (_jsxs("div", { className: c.row, children: [_jsxs("span", { className: c.muted, children: [i + 1, "."] }), _jsx(TextInput, { label: "Title, author, publisher", value: item.text, onChange: text => set(replaceAt(items, i, { ...item, text: text ?? '' })) }), _jsx(TextInput, { label: "Address", type: "url", placeholder: "https://", optional: true, value: item.url, onChange: url => set(replaceAt(items, i, { ...item, url })) }), _jsx(Remove, { label: `Remove ${noun} ${i + 1}`, onPress: () => set(removeAt(items, i)) })] }, item.id))), _jsxs(Add, { onPress: () => set([...items, { id: newId(), text: '' }]), children: ["Add ", noun] }), hint && _jsx("small", { className: c.muted, children: hint })] }));
+}
+export function LinkGridFields({ block, onUpdate }) {
+    const c = useEditorContext().kit.classNames;
+    const groups = block.groups;
+    return (_jsxs("div", { className: c.stack, children: [_jsx(Field, { label: "Intro (optional)", children: _jsx(TextInput, { label: "Intro", placeholder: "A paragraph before the groups", optional: true, value: block.intro, onChange: intro => onUpdate({ ...block, intro }) }) }), groups.map((group, gi) => {
+                const setGroup = (next) => onUpdate({ ...block, groups: replaceAt(groups, gi, next) });
+                return (_jsxs("div", { className: cx(c.nest, c.stack), children: [_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Heading", value: group.heading, onChange: heading => setGroup({ ...group, heading: heading ?? '' }) }), _jsx(Remove, { label: `Remove group ${group.heading || gi + 1}`, onPress: () => onUpdate({ ...block, groups: removeAt(groups, gi) }) })] }), _jsx(TextInput, { label: "Description", placeholder: "Description (optional)", optional: true, value: group.description ?? undefined, onChange: description => setGroup({ ...group, description }) }), group.links.map((link, li) => (_jsxs("div", { className: c.row, children: [_jsx(TextInput, { label: "Label", value: link.label, onChange: label => setGroup({ ...group, links: replaceAt(group.links, li, { ...link, label: label ?? '' }) }) }), _jsx(TextInput, { label: "Address", placeholder: "/path or https://", value: link.href, onChange: href => setGroup({ ...group, links: replaceAt(group.links, li, { ...link, href: href ?? '' }) }) }), _jsx(Remove, { label: `Remove link ${link.label || li + 1}`, onPress: () => setGroup({ ...group, links: removeAt(group.links, li) }) })] }, li))), _jsx(Add, { onPress: () => setGroup({ ...group, links: [...group.links, { label: '', href: '' }] }), children: "Add link" })] }, group.id));
+            }), _jsx(Add, { onPress: () => onUpdate({ ...block, groups: [...groups, { id: newId(), heading: '', links: [] }] }), children: "Add group" })] }));
+}
+export function BannerFields({ block, onUpdate }) {
+    const c = useEditorContext().kit.classNames;
+    return (_jsxs("div", { className: c.stack, children: [_jsx(Choice, { label: "Notice", value: block.variant, options: BANNER_VARIANTS, onChange: v => onUpdate({ ...block, variant: v }) }), _jsx(Field, { label: "Custom message (optional)", children: _jsx(TextInput, { label: "Custom message", placeholder: "Empty for the standard notice", optional: true, value: block.text, onChange: text => onUpdate({ ...block, text }) }) })] }));
+}
+/**
+ * The picked pages in their order, each movable and removable. With `pages`
+ * the rest are offered in a picker; without, an id is typed in.
+ */
+export function PageListFields({ block, onUpdate, pages }) {
+    const { kit } = useEditorContext();
+    const c = kit.classNames;
+    const [typed, setTyped] = useState('');
+    const ids = block.pageIds;
+    const set = (pageIds) => onUpdate({ ...block, pageIds });
+    const byId = new Map(pages?.map(p => [p.id, p]));
+    const full = ids.length >= MAX_BLOCK_ROWS;
+    const add = (id) => {
+        if (id && !ids.includes(id) && !full)
+            set([...ids, id]);
+    };
+    const unpicked = pages?.filter(p => !ids.includes(p.id)) ?? [];
+    const ops = {
+        move: (from, to) => {
+            const next = removeAt(ids, from);
+            next.splice(to, 0, ids[from]);
+            set(next);
+        },
+        duplicate: () => { },
+        remove: (i) => set(removeAt(ids, i)),
+    };
+    return (_jsxs("div", { className: c.stack, children: [ids.map((id, i) => {
+                const page = byId.get(id);
+                return (_jsxs("div", { className: c.row, children: [_jsxs("span", { className: c.muted, children: [i + 1, "."] }), _jsxs("span", { children: [pages ? (page?.title ?? `No such page: ${id}`) : id, page?.detail && _jsxs("span", { className: c.muted, children: [" \u00B7 ", page.detail] })] }), _jsx(BlockActions, { index: i, total: ids.length, ops: ops, icons: { up: kit.icons.up, down: kit.icons.down, remove: kit.icons.remove }, className: c.cardActions, buttonClassName: c.action, blockLabel: "page" })] }, i));
+            }), pages && pages.length === 0 && _jsx("p", { className: c.muted, children: "This wiki has no pages to pick yet." }), !full && pages && unpicked.length > 0 && (_jsx(Field, { label: "Add a page", children: _jsxs("select", { className: c.input, value: "", onChange: e => add(e.target.value), children: [_jsx("option", { value: "", children: "Choose\u2026" }), unpicked.map(p => (_jsx("option", { value: p.id, children: p.detail ? `${p.title} · ${p.detail}` : p.title }, p.id)))] }) })), !full && !pages && (_jsxs("div", { className: c.row, children: [_jsx("input", { type: "text", className: c.input, "aria-label": "Page id", placeholder: "Page id", value: typed, onChange: e => setTyped(e.target.value), onKeyDown: e => {
+                            if (e.key !== 'Enter')
+                                return;
+                            e.preventDefault();
+                            add(typed.trim());
+                            setTyped('');
+                        } }), _jsx(Add, { onPress: () => {
+                            add(typed.trim());
+                            setTyped('');
+                        }, children: "Add page" })] }))] }));
+}
+const GAPS = ['sm', 'md', 'lg'].map(v => ({ value: v, label: v }));
+const ALIGNS = ['start', 'center', 'end', 'stretch'].map(v => ({ value: v, label: v }));
+const MAX_COLUMNS = 4;
+/** Two to four columns, each a block list offering the schema's `nestedTypes`. */
+export function ColumnsFields({ block, onUpdate }) {
+    const c = useEditorContext().kit.classNames;
+    const columns = block.columns;
+    return (_jsxs("div", { className: c.stack, children: [_jsxs("div", { className: c.row, children: [_jsx(Choice, { label: "Gap", value: block.gap ?? 'md', options: GAPS, onChange: gap => onUpdate({ ...block, gap: gap }) }), _jsx(Choice, { label: "Align", value: block.align ?? 'start', options: ALIGNS, onChange: align => onUpdate({ ...block, align: align }) })] }), _jsx("div", { className: c.columns, children: columns.map((column, ci) => (_jsxs("div", { className: cx(c.nest, c.stack), children: [_jsxs("div", { className: c.cardHead, children: [_jsxs("span", { className: c.cardLabel, children: ["Column ", ci + 1] }), columns.length > 1 && _jsx(Remove, { label: `Remove column ${ci + 1}`, onPress: () => onUpdate({ ...block, columns: removeAt(columns, ci) }) })] }), _jsx(BlockList, { nested: true, blocks: column.blocks, onChange: blocks => onUpdate({ ...block, columns: replaceAt(columns, ci, { ...column, blocks: blocks }) }) })] }, column.id))) }), columns.length < MAX_COLUMNS && _jsx(Add, { onPress: () => onUpdate({ ...block, columns: [...columns, { id: newId(), blocks: [] }] }), children: "Add column" })] }));
+}
+/** An infobox's blocks, offering the schema's `nestedTypes`. */
+export function InfoboxFields({ block, onUpdate }) {
+    return _jsx(BlockList, { nested: true, blocks: block.blocks, onChange: blocks => onUpdate({ ...block, blocks: blocks }) });
+}

package/dist/block-views.js

@@ -2,9 +2,8 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 // block-views.tsx — the block leaves the wikis share.
 //
-// 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 still
-// installs a package with no runtime dependencies.
+// 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
 // that way (see the Block Model note in the workspace CLAUDE.md) — a closed

package/dist/blocks.d.ts

@@ -1,5 +1,6 @@
 import { type RelativeTimeStyle } from './freshness.js';
 import type { BlockGroup } from './revisions.js';
+import { type BannerVariant } from './text.js';
 /**
  * The languages a code block or code tab offers, and the one a new one opens
  * on. Two wikis carried this list character for character; a wiki with its own
@@ -50,6 +51,72 @@ export interface LinkGridGroup {
     description?: string | null;
     links: readonly LinkGridLink[];
 }
+export type EditableCodeTab = CodeTab & {
+    language: string;
+};
+export type EditableStatItem = StatItem & {
+    id: string;
+    value: string;
+};
+export type EditableReferenceItem = ReferenceItem & {
+    id: string;
+    url?: string;
+};
+export type EditableLinkGridGroup = LinkGridGroup & {
+    id: string;
+    links: LinkGridLink[];
+};
+export interface ContentBlock {
+    id: string;
+    type: 'content';
+    text: string;
+}
+export interface CodeTabsBlock {
+    id: string;
+    type: 'codeTabs';
+    tabs: EditableCodeTab[];
+}
+export interface StatsBlock {
+    id: string;
+    type: 'stats';
+    items: EditableStatItem[];
+    columns: 2 | 3 | 4;
+}
+export interface LinkGridBlock {
+    id: string;
+    type: 'linkGrid';
+    intro?: string;
+    groups: EditableLinkGridGroup[];
+}
+export interface ReferencesBlock {
+    id: string;
+    type: 'references';
+    title?: string;
+    items: EditableReferenceItem[];
+}
+/** A Wikipedia-style notice. `text` replaces the variant's standard message. */
+export interface BannerBlock {
+    id: string;
+    type: 'banner';
+    variant: BannerVariant;
+    text?: string;
+}
+/** `A` is the wiki's atomic union: a container never holds another container. */
+export interface ColumnsBlock<A> {
+    id: string;
+    type: 'columns';
+    columns: {
+        id: string;
+        blocks: A[];
+    }[];
+    gap?: 'sm' | 'md' | 'lg';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+}
+export interface InfoboxBlock<A> {
+    id: string;
+    type: 'infobox';
+    blocks: A[];
+}
 export interface BlockTreeOptions<B> {
     /** Render one leaf block. Return `''` to drop it from the document. */
     atomic: (block: B) => string;

package/dist/crawlers.d.ts

@@ -14,8 +14,8 @@ export interface AiCrawler {
 }
 /**
  * Structurally what Next's `MetadataRoute.Robots['rules']` wants, without
- * importing Next: this package has no runtime dependencies and is not going to
- * grow one for a shape that is three optional string fields.
+ * importing Next: this package does not depend on Next and is not going to for
+ * a shape that is three optional string fields.
  */
 export interface RobotsGroup {
     userAgent: string;

package/dist/db.d.ts

@@ -19,3 +19,28 @@ export interface PgPoolConfig {
  * a page that fans out more than three queries in thirty seconds.
  */
 export declare function pgPoolConfig(url: string | undefined): PgPoolConfig;
+/**
+ * What every app's prisma.config.ts hands `defineConfig`, from the folder the
+ * file sits in: `defineConfig(prismaConfig(import.meta.dirname))`. Four apps
+ * carried the file, three of them byte for byte.
+ *
+ * Read only by the Prisma CLI, never by the app, so the URL prefers DIRECT_URL:
+ * every CLI operation that connects (db push, migrate diff, studio) needs a
+ * session connection, and Supabase's transaction pooler on 6543, which
+ * DATABASE_URL names, hangs on them rather than failing. A placeholder stands
+ * in where neither is set, as on a Vercel build: `prisma generate` reads the
+ * schema and never connects, and anything that does connect fails loudly.
+ *
+ * `schema` is a folder of .prisma files (`prisma-models` writes beside the
+ * app's own) or a single file. Paths resolve against `root`, so the CLI works
+ * from a subdirectory.
+ */
+export declare function prismaConfig(root: string, schema?: string): {
+    schema: string;
+    migrations: {
+        path: string;
+    };
+    datasource: {
+        url: string;
+    };
+};