smoodly 0.0.8 → 0.0.9

package/README.md

@@ -314,8 +314,28 @@ Implemented:
   with "used on N pages" from `refs`. Wired through the `shared` option
   on the entry store and the site layer.
 
-Not yet: richtext components (TipTap; `plainToRichtext`/
-`richtextToPlain` exist but no rich editor widget), drag-and-drop
+- Lists and editable objects (spec 2026-09-07 list field): `f.list(item)`
+  holds any builder but another list and refuses a ref or `.localized()`
+  anywhere inside (refs are top-level only; localization is whole-value on
+  a list or object). `.min`/`.max` count items. The admin edits an object
+  as an indented fieldset and a list as rows — summary, collapse, move up
+  and down, remove, "N of max", Add disabled at max — recursively through
+  `FieldWidget`, with the row logic as pure functions in `admin/forms/list.ts`.
+  `validateFields` recurses with dotted paths (`points.2.heading`) and
+  checks list length; the serializer ships a list's `item`.
+
+- Richtext renders and round-trips: `RichText` (package root, pure React,
+  no wrapper) turns the TipTap document into paragraphs, headings, lists,
+  blockquotes, hard breaks and bold/italic/link marks, unknown nodes
+  degrading to their children. The interim textarea widget speaks a line
+  syntax (`#` headings, `- ` and `1. ` lists, `> ` quotes, blank line
+  between paragraphs, hard break between adjacent lines) over the same
+  JSON, so seeded structure survives an edit.
+  A link mark reaches the page only with a safe scheme (http(s), mailto,
+  tel, site-relative).
+
+Not yet: the TipTap richtext widget (the textarea's line syntax is the
+interim editor; `RichText` renders), Elements in richtext, drag-and-drop
 reordering (move-up/move-down buttons in the editor, Move up / Move down
 in the Pages list's row menu), undo/redo, sample/placeholder content
 marking, per-locale section visibility conditions (OQ #3 — each locale
@@ -336,6 +356,115 @@ Both packages move together. From the repo root:
 `examples/site` in that build, so the template always matches the example
 site at the tagged commit.
 
+## Follow-ups (logged 2026-09-07, starter)
+
+- A paired component (`smoodly.section`) accepts only its schema's props, so
+  a layout cannot hand the footer the contact item or the header the locale
+  links through the paired `Footer`/`Header`; the starter's layouts render
+  `FooterView`/`HeaderView` directly with the extra prop. A supported way
+  to pass layout-only props through a paired component (or a `children`
+  slot) would let the layouts use the registered component.
+- Page views and entry pages receive no `locale`; the starter's views get
+  it from the app's strings seam (`next-intl`'s `getLocale`, or a constant
+  in the single-language scaffold). Adding `locale` to `PageContext` and
+  `EntryPageProps` would remove that dependency and let sections that
+  format dates stay synchronous.
+- The content API is published-only, so the Articles index in the editor
+  canvas lists published articles while the hero above it is the draft.
+  A draft-aware `getEntries` for draft mode is the fix if that confuses.
+- The image widget edits the URL only; `alt` is set by the seed and cannot
+  be changed in the admin.
+- A per-locale collection path or fixed slug must name the default locale;
+  the installer rewrites the starter's two lines to name exactly the
+  chosen locales (`articlesSegments` in `scaffold.ts`), since a path
+  claiming a locale the site lacks fails the index-page rule at config
+  load. A "fall back to the first declared segment" rule in
+  `defineConfig` would make the patch unnecessary.
+- The picker offers a shared item only in zones whose allow list includes
+  its section (`allowedShared` in `admin/tree-ops.ts`), so a shared item's
+  section is always also offered as an ordinary section. A "placeable
+  only" mode (a shared item whose section no zone lists) would let the
+  starter keep the quote shared-only.
+- Registry names are one namespace across sections, elements, collections
+  and page shapes (`assertUniqueNames`); the starter names its People
+  section `peopleSection` and its Articles page `articlesIndex` to stay
+  clear of the collections. Namespacing by kind would let a section and a
+  collection share a name.
+- The seed's early exit probes `/` alone, and `createPage` writes the path
+  row before the tree is published, so a crash between the home record and
+  the last page leaves a database every later run reports as "already
+  seeded"; recovery is `supabase db reset`. A probe on the last thing the
+  seed writes, or a per-step check, would make it resumable.
+- With `fi` as the default locale the seed writes the English content into
+  `fi`. Before this fix the index page was seeded at `posts`
+  while the collection's `fi` path is `artikkelit`, so `ensureFixedNodes`
+  materialized a second, empty Articles page at `artikkelit` and the
+  links pointed at `/posts`; the seed now derives the segment from the
+  collection's `path` per locale. Left: the starter's copy in a `fi`
+  default is still English.
+- Config-level section style defaults (`styles.sections` in `defineConfig`)
+  are not filled at render: a node saved without an explicit style emits
+  no `data-spacing`/`data-tone`, so a stylesheet cannot key the default
+  on the attribute. The starter pads body sections by element instead.
+  Filling the resolved defaults in the render pass (as the admin form
+  does) would make the attributes reliable (walk, 2026-09-07).
+- A new list item's `select` subfield shows the first option but stores
+  nothing (`emptyValue` leaves it undefined), so publish fails with
+  `points.3.icon: Required` until the editor re-picks the value that is
+  already on screen. Seed the first option, or render a blank option so
+  the screen matches the value (walk, 2026-09-07).
+- Publish validates the last saved draft, so a click inside the autosave
+  debounce reports fields the editor has just filled as `Required`. Flush
+  the pending save before validating, or disable Publish while a save is
+  pending (walk, 2026-09-07).
+- The entry form cannot republish a published entry's newer draft: Save
+  writes a new draft version, the status control's `setPublished` returns
+  early when the status is unchanged, and nothing shows that the draft
+  differs from the published version. The workaround unpublishes and
+  republishes, which 404s the entry in between. Needs a "Publish changes"
+  action and a draft-edits indicator like the page editor's (walk,
+  2026-09-07).
+- Versions accumulate (`entry_versions` grew to four rows after one edit)
+  but no admin screen lists or restores them (walk, 2026-09-07).
+- A list row's collapsed summary shows the item's first string subfield —
+  the header nav rows read `/`, `/posts` — where the label would identify
+  the row; `itemSummary` could prefer a `label`/`title`/`heading` key
+  (walk, 2026-09-07).
+- New page / New folder ask for the slug through `window.prompt`, which
+  browser automation blocks and which cannot validate as you type; an
+  inline field would do both (walk, 2026-09-07).
+
+## Follow-ups (logged 2026-09-07, list field spec)
+
+- Saving the interim richtext textarea drops marks (bold, italic, link);
+  flattens a hard break inside a heading, list item or blockquote line to a
+  space (a prefixed line cannot carry one, DESIGN.md §3 Richtext); and drops
+  anything the line syntax cannot express at all — nested lists,
+  multi-paragraph list items (joined with a space instead), and unknown
+  nodes such as a horizontal rule. All of it goes away with the TipTap
+  widget.
+- Refs inside lists and objects are refused at build time (`f.list`,
+  `f.object`). A list of objects each holding a ref (a featured entry with
+  its own caption) needs the resolver, the refs index and the admin's
+  ref-option loading to address nested paths; add when a site asks.
+- Heading levels 4–6 render but the line syntax writes `####`…`######`
+  for them; the spec names 1–3 as the supported set.
+- `emptyValue` for an `image`/`video`/`file` item is `undefined`, so a new
+  media row starts empty; a required image item is then a validation
+  error until filled, which is the intended nudge but reads as an error
+  on a row the editor just added.
+- `RichText` drops the anchor of a link mark whose href is not http(s),
+  mailto, tel or site-relative (`/`, `#`, `?`, `.`). The href is normalised
+  the way URL parsers do (tab, LF and CR removed) before the scheme test;
+  `javascript:`, `data:`, protocol-relative `//host` and the backslash form
+  `/\host` are rejected. The admin's link field does not validate on input yet.
+- The list widget has no test for an object item holding a nested list
+  subfield.
+- A list item's subtree still uses the row index as its React key, so a list
+  of objects each holding a list hands the inner rows another item's collapse
+  state when an outer row moves; fix with a stable per-item key when nested
+  lists get real use.
+
 ## Follow-ups (logged 2026-09-07, shared content spec)
 
 - `f.shared(() => item)` — a ref field on a section that renders a shared
@@ -361,15 +490,12 @@ site at the tagged commit.
 - `getSmoodlyShared` reads the store per request in draft mode and once
   per (item, locale) otherwise; a layout calling it for several items
   makes one round trip each — batch if it shows.
-- The Supabase entry store's singleton check is SELECT-then-INSERT with
-  no unique index; two admin loads racing on an item's first
-  materialization can create two rows. `ensureSharedItems` reads the
-  first row either way, and the duplicate cannot be removed through the
-  API — `delete` refuses every shared row. Two ways to make the race
-  impossible: a deterministic row id (uuid v5 of the item name, so the
-  second insert fails on the primary key — no schema change), or a
-  per-item partial unique index emitted by the SQL generator the way
-  `collectionSQL` emits the rest.
+- A shared item's row id is now uuid v5 of (space, name), so the primary
+  key ends the materialization race — but only for rows created from now
+  on: an item materialized before this change keeps its random
+  `gen_random_uuid()` id, and a second load would still be able to insert
+  a duplicate beside it. Re-materializing such an item (delete the row in
+  SQL, reload the admin) moves it onto the derived id.
 - `SharedForm.tsx` is a near-verbatim fork of `EntryForm.tsx`
   (`localeFromUrl`, `writeLocaleToUrl`, `applyResult`, `InfoRow`, the
   ref-options effect) and `SharedList.tsx` is the third copy of the
@@ -408,6 +534,14 @@ site at the tagged commit.
 - `ops.entries.move` expires entry tags directly and does not `fanOut`,
   so a reorder that changes what a shared item's `refList` renders does
   not expire `shared:<name>`.
+- The package root (`src/index.ts`) must stay free of Node builtins:
+  every scaffolded section does `import { f, smoodly } from "smoodly"`,
+  and a `"use client"` section's browser build would fail on one.
+  `sharedEntryId` (`src/shared-id.ts`) moved off `node:crypto` onto Web
+  Crypto for this reason (fix pass, 2026-09-07). Nothing tests the
+  invariant itself — a future addition that reaches for `node:fs`,
+  `node:crypto`, etc. from a module reachable through the root would
+  regress it silently.
 
 ## Follow-ups (logged 2026-09-06)
 

package/dist/admin/forms/FieldWidget.d.ts

@@ -1,10 +1,14 @@
-import type { ReactElement } from "react";
+import { type ReactElement } from "react";
 import type { AdminField } from "../serialize.ts";
-export declare function FieldWidget({ descriptor: d, value, onChange, error, refOptions, fieldKey, prefix, }: {
+export declare function FieldWidget({ descriptor: d, value, onChange, errors, path: pathProp, bare, refOptions, fieldKey, prefix, }: {
     descriptor: AdminField;
     value: unknown;
     onChange(value: unknown): void;
-    error?: string;
+    errors?: Record<string, string>;
+    /** Dotted path of this widget in the form; defaults to `fieldKey`. */
+    path?: string;
+    /** Render the control alone, no label wrapper — list items. */
+    bare?: boolean;
     refOptions?: {
         id: string;
         title: string;

package/dist/admin/forms/FieldWidget.js

@@ -1,11 +1,26 @@
 "use client";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// One schema descriptor → one labelled control, in the design system's
+// field language: uppercase 9px label, inset control with no border at
+// rest, 1.5px accent border + soft ring on focus (all in ui/theme.tsx).
+// Objects and lists recurse through this same component; the list's
+// logic lives in ./list.ts as pure functions.
+import { useState } from "react";
 import { plainToRichtext, richtextToPlain } from "../richtext.js";
-import { Field, IconButton } from "../ui/primitives.js";
+import { Button, Field, IconButton } from "../ui/primitives.js";
+import { addItem, itemSummary, moveIndex, moveItem, patchObject, removeIndex, removeItem } from "./list.js";
 const label = (key) => key.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
-export function FieldWidget({ descriptor: d, value, onChange, error, refOptions = [], fieldKey, prefix, }) {
+export function FieldWidget({ descriptor: d, value, onChange, errors, path: pathProp, bare, refOptions = [], fieldKey, prefix, }) {
+    const path = pathProp ?? fieldKey;
+    const message = errors?.[path];
+    // Unused for non-list types, but hooks must be unconditional — a list's
+    // rows key their collapse state to this rather than to array position,
+    // so a move or remove doesn't reassign which row looks open.
+    const [collapsed, setCollapsed] = useState(() => new Set());
     const optionTitle = (o) => o.status === "draft" ? `${o.title} (draft)` : o.title;
     let control;
+    let counter;
+    let asDiv = d.type === "refList";
     switch (d.type) {
         case "text":
         case "link":
@@ -26,7 +41,7 @@ export function FieldWidget({ descriptor: d, value, onChange, error, refOptions
             break;
         }
         case "richtext":
-            control = (_jsx("textarea", { className: "sm-textarea", rows: 5, value: richtextToPlain(value), onChange: (e) => onChange(plainToRichtext(e.target.value)) }));
+            control = _jsx(RichtextArea, { value: value, onChange: onChange });
             break;
         case "image":
         case "video":
@@ -44,11 +59,74 @@ export function FieldWidget({ descriptor: d, value, onChange, error, refOptions
             control = (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: [ids.map((id, i) => (_jsxs("div", { style: { display: "flex", gap: 6, alignItems: "center" }, children: [_jsx("span", { className: "sm-input", style: { display: "flex", alignItems: "center", flex: 1 }, children: byId.get(id) ? optionTitle(byId.get(id)) : id }), _jsx(IconButton, { label: "Remove", size: 28, onClick: () => onChange(ids.filter((_, j) => j !== i)), children: "\u00D7" })] }, `${id}-${i}`))), _jsxs("select", { className: "sm-select", value: "", onChange: (e) => e.target.value && onChange([...ids, e.target.value]), children: [_jsx("option", { value: "", children: "Add\u2026" }), refOptions.filter((o) => !ids.includes(o.id)).map((o) => (_jsx("option", { value: o.id, children: optionTitle(o) }, o.id)))] })] }));
             break;
         }
+        case "object": {
+            asDiv = true;
+            const obj = (value && typeof value === "object" && !Array.isArray(value) ? value : {});
+            control = (_jsx("div", { className: "sm-group", children: Object.entries(d.fields ?? {}).map(([k, sub]) => (_jsx(FieldWidget, { fieldKey: k, descriptor: sub, value: obj[k], errors: errors, path: `${path}.${k}`, onChange: (v) => onChange(patchObject(obj, k, v, d.optional === true)) }, k))) }));
+            break;
+        }
+        case "list": {
+            asDiv = true;
+            const items = Array.isArray(value) ? value : [];
+            const item = d.item ?? { type: "text" };
+            const atMax = typeof d.max === "number" && items.length >= d.max;
+            if (typeof d.max === "number")
+                counter = `${items.length} of ${d.max}`;
+            control = (_jsxs("div", { className: "sm-list", children: [items.map((it, i) => (_jsx(ListRow, { index: i, count: items.length, summary: itemSummary(it, i), open: !collapsed.has(i), onToggle: () => setCollapsed((prev) => {
+                            const next = new Set(prev);
+                            if (next.has(i))
+                                next.delete(i);
+                            else
+                                next.add(i);
+                            return next;
+                        }), onMove: (to) => {
+                            const moved = moveItem(items, i, to);
+                            if (moved !== items) {
+                                onChange(moved);
+                                setCollapsed((prev) => moveIndex(prev, i, to));
+                            }
+                        }, onRemove: () => {
+                            onChange(removeItem(items, i));
+                            setCollapsed((prev) => removeIndex(prev, i));
+                        }, children: _jsx(FieldWidget, { fieldKey: String(i), descriptor: item, value: it, errors: errors, path: `${path}.${i}`, bare: true, onChange: (v) => onChange(items.map((x, j) => (j === i ? v : x))) }) }, i))), _jsx(Button, { variant: "secondary", disabled: atMax, onClick: () => onChange(addItem(items, d)), children: "Add" })] }));
+            break;
+        }
         default:
             control = _jsx("textarea", { className: "sm-textarea", disabled: true, value: JSON.stringify(value ?? null, null, 2), rows: 2 });
     }
+    if (bare) {
+        return (_jsxs(_Fragment, { children: [control, message && _jsx("span", { className: "sm-error", children: message })] }));
+    }
     // A <label> activates its first labelable descendant, so it may only wrap a
-    // single control — around refList's rows it would turn every click into a
-    // press of the first row's remove button.
-    return (_jsx(Field, { label: label(fieldKey), error: error, asDiv: d.type === "refList", children: control }));
+    // single control — around refList's rows, an object's fieldset or a list's
+    // rows it would turn every click into a press of the first button.
+    return (_jsx(Field, { label: label(fieldKey), counter: counter, error: message, asDiv: asDiv, children: control }));
+}
+/** One list item: a header with the summary and the row controls, the
+ *  item's widget underneath while expanded. Header is a div, not a label.
+ *  Collapse state lives in the parent `FieldWidget`, keyed to the item's
+ *  index rather than to `key={i}` position, so a move or remove doesn't
+ *  hand this row someone else's open/closed state. */
+function ListRow({ index, count, summary, open, onToggle, onMove, onRemove, children }) {
+    return (_jsxs("div", { className: "sm-listrow", children: [_jsxs("div", { className: "sm-listrow__head", children: [_jsxs("button", { type: "button", className: "sm-listrow__toggle", "aria-expanded": open, onClick: onToggle, children: [_jsx("span", { "aria-hidden": "true", children: open ? "▾" : "▸" }), _jsx("span", { className: "sm-listrow__summary", children: summary })] }), _jsx(IconButton, { label: "Move up", disabled: index === 0, onClick: () => onMove(index - 1), children: "\u2191" }), _jsx(IconButton, { label: "Move down", disabled: index === count - 1, onClick: () => onMove(index + 1), children: "\u2193" }), _jsx(IconButton, { label: "Remove", onClick: onRemove, children: "\u00D7" })] }), open && _jsx("div", { className: "sm-listrow__body", children: children })] }));
+}
+/** The interim richtext widget owns its text: the line syntax drops a trailing
+ *  newline on the round trip, so deriving the value from the document each
+ *  render would snap the caret back after Enter at the end of the text. Re-seeds
+ *  when the document changes underneath it (load, locale switch). The parent must
+ *  store the emitted document by reference — a clone or a server copy handed back
+ *  would re-seed the text and bring the caret snap back. */
+function RichtextArea({ value, onChange }) {
+    const [text, setText] = useState(() => richtextToPlain(value));
+    const [seen, setSeen] = useState(value);
+    if (value !== seen) {
+        setSeen(value);
+        setText(richtextToPlain(value));
+    }
+    return (_jsx("textarea", { className: "sm-textarea", rows: 5, value: text, onChange: (e) => {
+            const doc = plainToRichtext(e.target.value);
+            setText(e.target.value);
+            setSeen(doc);
+            onChange(doc);
+        } }));
 }

package/dist/admin/forms/list.d.ts

@@ -0,0 +1,18 @@
+import type { AdminField } from "../serialize.ts";
+/** An empty item: an object of its subfields' defaults, else the default. */
+export declare function emptyValue(d: AdminField): unknown;
+export declare function addItem(items: unknown[], list: AdminField): unknown[];
+export declare function removeItem(items: unknown[], index: number): unknown[];
+export declare function moveItem(items: unknown[], from: number, to: number): unknown[];
+/** Permutes a set of item indices (e.g. collapse state) for the same move
+ *  `moveItem` just applied: the index at `from` becomes `to`; indices strictly
+ *  between the two shift by one toward `from`; every other index is unchanged. */
+export declare function moveIndex(set: Set<number>, from: number, to: number): Set<number>;
+/** Permutes a set of item indices for a removal at `index`: drops it, and
+ *  shifts every higher index down by one. */
+export declare function removeIndex(set: Set<number>, index: number): Set<number>;
+/** The row header's text: the value, or its first non-empty string, or "Item N". */
+export declare function itemSummary(value: unknown, index: number): string;
+/** A subfield change on an object value. `collapseEmpty` (an optional
+ *  object) turns an object with no defined values into `undefined`. */
+export declare function patchObject(obj: Record<string, unknown>, key: string, value: unknown, collapseEmpty: boolean): Record<string, unknown> | undefined;

package/dist/admin/forms/list.js

@@ -0,0 +1,81 @@
+/** An empty item: an object of its subfields' defaults, else the default. */
+export function emptyValue(d) {
+    if (d.type === "object") {
+        const out = {};
+        for (const [k, sub] of Object.entries(d.fields ?? {})) {
+            const v = emptyValue(sub);
+            if (v !== undefined)
+                out[k] = v;
+        }
+        return out;
+    }
+    return d.default;
+}
+export function addItem(items, list) {
+    if (typeof list.max === "number" && items.length >= list.max)
+        return items;
+    return [...items, list.item ? emptyValue(list.item) : undefined];
+}
+export function removeItem(items, index) {
+    return items.filter((_, i) => i !== index);
+}
+export function moveItem(items, from, to) {
+    if (to < 0 || to >= items.length || from === to)
+        return items;
+    const next = [...items];
+    const [moved] = next.splice(from, 1);
+    next.splice(to, 0, moved);
+    return next;
+}
+/** Permutes a set of item indices (e.g. collapse state) for the same move
+ *  `moveItem` just applied: the index at `from` becomes `to`; indices strictly
+ *  between the two shift by one toward `from`; every other index is unchanged. */
+export function moveIndex(set, from, to) {
+    const next = new Set();
+    for (const i of set) {
+        if (i === from)
+            next.add(to);
+        else if (from < to && i > from && i <= to)
+            next.add(i - 1);
+        else if (to < from && i >= to && i < from)
+            next.add(i + 1);
+        else
+            next.add(i);
+    }
+    return next;
+}
+/** Permutes a set of item indices for a removal at `index`: drops it, and
+ *  shifts every higher index down by one. */
+export function removeIndex(set, index) {
+    const next = new Set();
+    for (const i of set) {
+        if (i === index)
+            continue;
+        next.add(i > index ? i - 1 : i);
+    }
+    return next;
+}
+const nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
+/** The row header's text: the value, or its first non-empty string, or "Item N". */
+export function itemSummary(value, index) {
+    if (nonEmpty(value))
+        return value;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const hit = Object.values(value).find(nonEmpty);
+        if (hit)
+            return hit;
+    }
+    return `Item ${index + 1}`;
+}
+/** A subfield change on an object value. `collapseEmpty` (an optional
+ *  object) turns an object with no defined values into `undefined`. */
+export function patchObject(obj, key, value, collapseEmpty) {
+    const next = { ...obj };
+    if (value === undefined)
+        delete next[key];
+    else
+        next[key] = value;
+    if (collapseEmpty && Object.values(next).every((v) => v === undefined))
+        return undefined;
+    return next;
+}

package/dist/admin/richtext.d.ts

@@ -1,14 +1,16 @@
-type TextNode = {
-    type: "text";
-    text: string;
+export type RichtextNode = {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: RichtextNode[];
+    text?: string;
+    marks?: {
+        type: string;
+        attrs?: Record<string, unknown>;
+    }[];
 };
-type Paragraph = {
-    type: "paragraph";
-    content?: TextNode[];
-};
-export declare function richtextToPlain(doc: unknown): string;
-export declare function plainToRichtext(text: string): {
+export type RichtextDoc = {
     type: "doc";
-    content: Paragraph[];
+    content: RichtextNode[];
 };
-export {};
+export declare function plainToRichtext(text: string): RichtextDoc;
+export declare function richtextToPlain(doc: unknown): string;

package/dist/admin/richtext.js

@@ -1,17 +1,98 @@
-export function richtextToPlain(doc) {
-    const d = doc;
-    if (!d || d.type !== "doc" || !Array.isArray(d.content))
-        return "";
-    return d.content
-        .map((p) => (p.content ?? []).map((t) => t.text ?? "").join(""))
-        .join("\n");
+const textOf = (s) => (s ? [{ type: "text", text: s }] : []);
+function paragraph(lines) {
+    const content = [];
+    lines.forEach((line, i) => {
+        if (i > 0)
+            content.push({ type: "hardBreak" });
+        content.push(...textOf(line));
+    });
+    return content.length > 0 ? { type: "paragraph", content } : { type: "paragraph" };
 }
+const listItem = (s) => ({ type: "listItem", content: [paragraph([s])] });
+const HEADING = /^(#{1,6}) (.*)$/;
+const BULLET = /^- /;
+const ORDERED = /^\d+\. /;
+const QUOTE = /^> ?/;
 export function plainToRichtext(text) {
-    return {
-        type: "doc",
-        content: text.split("\n").map((line) => ({
-            type: "paragraph",
-            ...(line ? { content: [{ type: "text", text: line }] } : {}),
-        })),
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    const content = [];
+    let para = [];
+    const flush = () => {
+        if (para.length > 0)
+            content.push(paragraph(para));
+        para = [];
     };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === "") {
+            flush();
+            i++;
+            continue;
+        }
+        const heading = HEADING.exec(line);
+        if (heading) {
+            flush();
+            content.push({ type: "heading", attrs: { level: heading[1].length }, content: textOf(heading[2]) });
+            i++;
+            continue;
+        }
+        if (BULLET.test(line) || ORDERED.test(line)) {
+            flush();
+            const ordered = ORDERED.test(line);
+            const re = ordered ? ORDERED : BULLET;
+            const items = [];
+            while (i < lines.length && re.test(lines[i])) {
+                items.push(listItem(lines[i].replace(re, "")));
+                i++;
+            }
+            content.push({ type: ordered ? "orderedList" : "bulletList", content: items });
+            continue;
+        }
+        if (QUOTE.test(line)) {
+            flush();
+            const paras = [];
+            while (i < lines.length && QUOTE.test(lines[i])) {
+                paras.push(paragraph([lines[i].replace(QUOTE, "")]));
+                i++;
+            }
+            content.push({ type: "blockquote", content: paras });
+            continue;
+        }
+        para.push(line);
+        i++;
+    }
+    flush();
+    return { type: "doc", content };
+}
+/** Inline text of a node: text runs joined, a hard break as a newline, marks ignored. */
+function inline(node) {
+    if (node.type === "text")
+        return node.text ?? "";
+    if (node.type === "hardBreak")
+        return "\n";
+    return (node.content ?? []).map(inline).join("");
+}
+/** Inline text of a node, with hard breaks flattened to spaces so the line syntax stays intact. A hard break cannot survive inside a prefixed line (list item, blockquote, or heading), so it flattens to a space (DESIGN.md §3 Richtext records the loss). */
+function oneLine(node) {
+    return inline(node).replace(/\n/g, " ");
+}
+const itemText = (li) => (li.content ?? []).map(oneLine).join(" ");
+function block(node) {
+    switch (node.type) {
+        case "heading": {
+            const level = Math.min(6, Math.max(1, Math.round(Number(node.attrs?.level ?? 1) || 1)));
+            return `${"#".repeat(level)} ${oneLine(node)}`;
+        }
+        case "bulletList": return (node.content ?? []).map((li) => `- ${itemText(li)}`).join("\n");
+        case "orderedList": return (node.content ?? []).map((li, i) => `${i + 1}. ${itemText(li)}`).join("\n");
+        case "blockquote": return (node.content ?? []).map((p) => `> ${oneLine(p)}`).join("\n");
+        default: return inline(node);
+    }
+}
+export function richtextToPlain(doc) {
+    const d = doc;
+    if (!d || typeof d !== "object" || d.type !== "doc" || !Array.isArray(d.content))
+        return "";
+    return d.content.map(block).filter((b) => b !== "").join("\n\n");
 }

package/dist/admin/serialize.d.ts

@@ -3,6 +3,10 @@ import type { ZonePolicy } from "../zones.ts";
 export type AdminField = Record<string, unknown> & {
     type: string;
     target?: string;
+    /** An object's subfields, serialized. */
+    fields?: Record<string, AdminField>;
+    /** A list's item descriptor, serialized. */
+    item?: AdminField;
 };
 export type AdminSection = {
     name: string;

package/dist/admin/serialize.js

@@ -10,6 +10,9 @@ function serializeDescriptor(d) {
         else if (key === "fields" && d.type === "object") {
             out.fields = serializeMap(value);
         }
+        else if (key === "item" && d.type === "list") {
+            out.item = serializeDescriptor(value);
+        }
         else if (typeof value !== "function") {
             out[key] = value;
         }

package/dist/admin/shell/EntryForm.js

@@ -223,7 +223,7 @@ export function EntryForm({ ops, registry, collection, id }) {
     const present = record ? registry.locales.supported.filter((l) => record.locales[l]) : [locale];
     const shared = Object.entries(meta.fields).filter(([key]) => !localeKeys.includes(key));
     const own = Object.entries(meta.fields).filter(([key]) => localeKeys.includes(key));
-    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], error: fieldErrors[key], refOptions: refTargets[key] ? refOptions[refTargets[key]] ?? [] : undefined, prefix: d.type === "slug" ? slugPrefix : undefined, onChange: (value) => { setFields((f) => ({ ...(f ?? {}), [key]: value })); setDirty(true); } }, key));
+    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], errors: fieldErrors, refOptions: refTargets[key] ? refOptions[refTargets[key]] ?? [] : undefined, prefix: d.type === "slug" ? slugPrefix : undefined, onChange: (value) => { setFields((f) => ({ ...(f ?? {}), [key]: value })); setDirty(true); } }, key));
     const absent = !isNew && record !== null && fields === null && !record.locales[locale];
     return (_jsxs(_Fragment, { children: [_jsx(TopBar, { left: _jsxs(_Fragment, { children: [_jsx(Breadcrumb, { backHref: `${BASE}/${collection}`, items: [{ label: meta.title, href: `${BASE}/${collection}` }, { label: heading }] }), multilingual && !isNew && (_jsx(LocaleSwitcher, { registry: registry, present: present, parentLocales: parentLocales, value: locale, adding: adding, onSwitch: switchLocale, onAdd: (l) => void doAddLocale(l) })), multilingual && isNew && _jsxs("span", { className: "sm-hint", children: ["\u00B7 ", locale] })] }), right: _jsx(Button, { onClick: save, disabled: fields === null, children: isNew ? "Create" : "Save" }) }), _jsxs("div", { style: { flex: 1, minHeight: 0, display: "grid", gridTemplateColumns: "1fr var(--inspector-w)" }, children: [_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 18, padding: "24px 32px", minWidth: 0, overflow: "auto" }, children: [banner && _jsx(Banner, { tone: banner.tone, onDismiss: () => setBanner(null), children: banner.text }), absent ? (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [_jsxs("p", { children: ["This entry doesn't exist in ", locale, " yet. Adding it copies the ", entrySourceLocale(record, registry), " fields as the first ", locale, " draft."] }), _jsxs("div", { style: { display: "flex", gap: 8 }, children: [_jsxs(Button, { onClick: () => void doAddLocale(locale), disabled: adding || !parentLocales.includes(locale), title: parentLocales.includes(locale) ? undefined : `add ${locale} to the parent first`, children: ["Add ", locale] }), _jsxs(Button, { variant: "secondary", onClick: () => switchLocale(entrySourceLocale(record, registry)), children: ["Back to ", entrySourceLocale(record, registry)] })] })] })) : fields !== null ? (_jsxs(_Fragment, { children: [shared.length > 0 && (_jsxs(_Fragment, { children: [multilingual && _jsx(SectionLabel, { children: "Shared across languages" }), shared.map(widget)] })), own.length > 0 && (_jsxs(_Fragment, { children: [multilingual && _jsxs(SectionLabel, { children: ["In ", locale] }), own.map(widget)] }))] })) : !banner && _jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" })] }), _jsxs("aside", { style: {
                             display: "flex", flexDirection: "column", gap: 16, padding: "16px 14px",

package/dist/admin/shell/SharedForm.js

@@ -135,7 +135,7 @@ export function SharedForm({ ops, registry, name }) {
     const own = Object.entries(item.fields).filter(([key]) => localeKeys.includes(key));
     const styles = (fields?.[STYLES_KEY] ?? {});
     const pages = new Set(usage.filter((u) => u.sourceKind === "page").map((u) => u.sourceId));
-    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], error: fieldErrors[key], refOptions: refTargets[key] ? refOptions[refTargets[key]] ?? [] : undefined, onChange: (value) => { setFields((f) => ({ ...(f ?? {}), [key]: value })); setDirty(true); } }, key));
+    const widget = ([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: fields?.[key], errors: fieldErrors, refOptions: refTargets[key] ? refOptions[refTargets[key]] ?? [] : undefined, onChange: (value) => { setFields((f) => ({ ...(f ?? {}), [key]: value })); setDirty(true); } }, key));
     return (_jsxs(_Fragment, { children: [_jsx(TopBar, { left: _jsxs(_Fragment, { children: [_jsx(Breadcrumb, { backHref: `${BASE}/shared`, items: [{ label: "Shared content", href: `${BASE}/shared` }, { label: item.title }] }), multilingual && (_jsx(LocaleSwitcher, { registry: registry, present: registry.locales.supported, parentLocales: [], value: locale, adding: false, onSwitch: switchLocale, onAdd: () => undefined }))] }), right: _jsx(Button, { onClick: save, disabled: fields === null, children: "Save" }) }), _jsxs("div", { style: { flex: 1, minHeight: 0, display: "grid", gridTemplateColumns: "1fr var(--inspector-w)" }, children: [_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 18, padding: "24px 32px", minWidth: 0, overflow: "auto" }, children: [banner && _jsx(Banner, { tone: banner.tone, onDismiss: () => setBanner(null), children: banner.text }), record && (_jsxs("p", { className: "sm-hint", children: [pages.size === 0 ? "Not placed on any page yet." : `Used on ${pages.size} page${pages.size === 1 ? "" : "s"}: `, [...pages].map((id, i) => (_jsxs("span", { children: [i > 0 && ", ", _jsx("a", { href: `${BASE}/pages/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`, children: id })] }, id)))] })), fields !== null ? (_jsxs(_Fragment, { children: [shared.length > 0 && (_jsxs(_Fragment, { children: [multilingual && _jsx(SectionLabel, { children: "Shared across languages" }), shared.map(widget)] })), own.length > 0 && (_jsxs(_Fragment, { children: [multilingual && _jsxs(SectionLabel, { children: ["In ", locale] }), own.map(widget)] })), item.section !== undefined && Object.keys(item.styles).length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionLabel, { children: "Styles" }), Object.entries(item.styles).map(([key, d]) => (_jsx(FieldWidget, { fieldKey: key, descriptor: d, value: styles[key], onChange: (value) => {
                                                     setFields((f) => ({ ...(f ?? {}), [STYLES_KEY]: { ...(f?.[STYLES_KEY] ?? {}), [key]: value } }));
                                                     setDirty(true);