smoodly 0.0.7 → 0.0.8

package/README.md

@@ -174,8 +174,9 @@ Implemented:
   for self-host: the anon key now reads published rows straight off the
   base tables (`pages` and `entries` published in any locale, a published
   `page_locales`/`entry_locales` row, the `page_versions`/`entry_versions`
-  row a published locale points at, `global_sections`), not only through
-  the generated views.
+  row a published locale points at — shared content included, since it
+  is stored as entries, spec 2026-09-07), not only through the generated
+  views.
 
 - Admin login: `supabaseAdminAuth` + `gateAdminOp` around the ops seam;
   `LoginView` + `useAdminSession` in the shell; `createSmoodlyAdmin({ auth })`.
@@ -301,6 +302,18 @@ Implemented:
   the only way the node gets there — it also covers pages that existed
   before a locked zone was added to their schema.
 
+- Shared content (spec 2026-09-07): `smoodly.shared({ name, title, section })`
+  registers a visual item, `smoodly.shared({ name, title, fields })` an
+  object item; one registration materializes as a singleton entry in
+  every supported locale. `site.getShared(item, { locale })` and the Next
+  glue's `getSmoodlyShared(item, { locale })` fetch it code-side; the
+  editor places a visual item in a zone from the "+" picker as a linked
+  `{ type: "shared", fields: { item, ref } }` node the resolve pass
+  rewrites into the section, and `z.locked(footer)` binds a zone to one.
+  Edited on its own admin page under Shared content (`/admin/shared/<name>`),
+  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
 reordering (move-up/move-down buttons in the editor, Move up / Move down
@@ -323,6 +336,79 @@ 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, shared content spec)
+
+- `f.shared(() => item)` — a ref field on a section that renders a shared
+  item inside the section's own markup (spec 2026-09-07 decision 3).
+- Instance mode: a shared *type* with many editor-created items; today
+  the answer is a collection plus a section with `f.ref` (decision 1).
+- Zone-shaped shared items (`smoodly.shared({ zone })`) (decision 2).
+- Standalone live preview on a visual item's admin page — needs a
+  preview route in the glue; the page canvas shows placements today (§6).
+- Built-in meta on shared items and on placements (anchor per placement
+  is the likely shape).
+- Per-placement overrides (a shared band with a per-page heading) — out
+  of scope; use a normal section with `f.ref` fields.
+- `fillLockedZones` for a zone bound to a shared item waits for
+  `ops.shared.list()`; a page opened before that resolves fills on the
+  next effect run. Not seen in the walk — the example binds no zone, so
+  the path was never exercised — but a double fill is unreachable by
+  construction: the effect depends on `sharedIds`, `record`, `mutate` and
+  `tree === null`, and `fillLockedZones` only touches EMPTY zones.
+  `z.locked(item)` still has no example usage.
+- `SharedForm` lists linking pages by id; a title needs `ops.pages.get`
+  per page (or a usage op returning titles).
+- `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.
+- `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
+  remembered-locale block (`EntriesList`, `PagesList`); extract
+  `shell/locale-url.ts` and a `useFormLocale` hook when the next form
+  arrives.
+- A placement selected in a bound locked zone shows the canvas toolbar's
+  "fields only" label though a placement has no page-level fields; the
+  inspector notice is the real message.
+- A zone whose policy allows a shared item's section also offers that
+  section as an ordinary block, so the picker lists e.g. Testimonials
+  twice (once under Shared); decide whether a section used by a shared
+  item should be hidden from the ordinary list.
+- A placement of an object item or an unregistered item gates the page's
+  publish (the refs edge is emitted without a registry lookup) yet never
+  renders; only a hand-edited tree can produce one.
+- `ops.shared.get` runs `ensureSharedItems` and then lists the item
+  again; one round trip could go.
+- The example's Testimonials `quotes` richtext is required, so the first
+  admin save of the seeded band asks for it; make it optional or seed it.
+- `CollectionSchema.kind` was widened to carry `"shared"`, so a
+  `SharedSchema` typechecks where `registry.collections` is expected;
+  `defineConfig` should throw on a `kind === "shared"` entry listed there.
+- `ensureSharedItems` runs on every `ops.shared.list()` — which is every
+  editor mount, not only the Shared content page — costing one
+  `entries.list` per registration per open.
+- `fanOut` resolves every shared registration's row id (one
+  `entries.list` each) on every entry write, so it can expire
+  `shared:<name>` when something the item references changes; a row-id
+  cache would remove the reads but has to survive materialization.
+- Because `fanOut` lists every shared registration, an entry store built
+  without `options.shared` now fails on every ordinary entry write with
+  "no collection named", not only on `ops.shared.*`; both scaffolds pass
+  the same `shared` array to the store and the config, so this bites only
+  a hand-wired app.
+- `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>`.
+
 ## Follow-ups (logged 2026-09-06)
 
 - Drag-and-drop in the Pages list — the ops it needs exist

package/dist/admin/client-ops.js

@@ -1,6 +1,7 @@
 const GROUPS = {
     pages: ["list", "get", "create", "saveDraft", "publish", "delete", "rename", "move", "setTemplate", "addLocale", "removeLocale"],
     entries: ["list", "get", "create", "save", "setStatus", "delete", "move", "addLocale", "removeLocale"],
+    shared: ["list", "get", "save", "setStatus"],
     preview: ["enable", "disable"],
 };
 export function makeClientOps(action, token) {

package/dist/admin/editor/EditorView.js

@@ -19,11 +19,13 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // Core code: no next/* imports live here — the bridge is the only piece
 // that knows about Next, and it ships to the site, not the admin.
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { SHARED_NODE_TYPE } from "../../shared.js";
 import { FieldWidget } from "../forms/FieldWidget.js";
 import { tabsFor } from "../forms/tabs.js";
-import { allowedSections, canInsert, fillLockedZones, findNode, insertNode, moveNode, newNodeId, nodeFromSample, patchNode, removeNode, zoneOf, } from "../tree-ops.js";
+import { allowedSections, allowedShared, canInsert, fillLockedZones, findNode, insertNode, moveNode, newNodeId, nodeFromSample, patchNode, placementNode, removeNode, zoneOf, } from "../tree-ops.js";
 import { useDraftAutosave } from "./autosave.js";
 import { PageSettings } from "./PageSettings.js";
+import { BASE } from "../shell/base.js";
 import { isFixedNode, localeStatusOf, sourceLocaleOf } from "../shell/pages-tree.js";
 import { entryTitle } from "../shell/entries-list.js";
 import { LocaleSwitcher } from "../ui/LocaleSwitcher.js";
@@ -81,6 +83,9 @@ export function EditorView({ ops, registry, id }) {
     const [banner, setBanner] = useState(null);
     const [published, setPublished] = useState(false);
     const [refOptions, setRefOptions] = useState({});
+    // Shared item name → row id, loaded once per editor mount: the picker's
+    // Shared group and a bound locked zone need the id to place a node.
+    const [sharedIds, setSharedIds] = useState(null);
     const [hoverPlus, setHoverPlus] = useState(null);
     const iframeRef = useRef(null);
     const scrollerRef = useRef(null);
@@ -290,6 +295,12 @@ export function EditorView({ ops, registry, id }) {
     const zoneOrder = useMemo(() => Object.keys(template?.zones ?? {}), [template]);
     const policyOf = useCallback((zone) => (zone ? template?.zones[zone] : undefined), [template]);
     const sectionOf = useCallback((type) => registry.sections.find((s) => s.name === type) ?? null, [registry]);
+    /** The shared item a placement node places, or null for any other node. */
+    const sharedOf = useCallback((node) => {
+        if (node.type !== SHARED_NODE_TYPE)
+            return null;
+        return registry.shared.find((s) => s.name === node.fields?.item) ?? null;
+    }, [registry]);
     // ── ref fields inside sections: same option loading as EntryForm ──────
     const refTargets = useMemo(() => {
         const out = {};
@@ -329,6 +340,27 @@ export function EditorView({ ops, registry, id }) {
         }
         return () => { cancelled = true; };
     }, [ops, refTargets, registry, locale]);
+    useEffect(() => {
+        if (registryRef.current.shared.length === 0) {
+            setSharedIds({});
+            return;
+        }
+        let cancelled = false;
+        // A failed load leaves the map empty: the picker's Shared group and
+        // any zone bound to an item degrade to nothing to place, not a stuck
+        // editor — so say why in the console, like the ref options above.
+        ops.shared.list()
+            .then((r) => {
+            if (cancelled)
+                return;
+            if (!r.ok)
+                console.error(r.message);
+            setSharedIds(r.ok ? Object.fromEntries(r.data.map((i) => [i.name, i.record.id])) : {});
+        })
+            .catch((e) => { console.error(e); if (!cancelled)
+            setSharedIds({}); });
+        return () => { cancelled = true; };
+    }, [ops]);
     // ── canvas messaging ─────────────────────────────────────────────────
     const postToCanvas = useCallback((m) => {
         iframeRef.current?.contentWindow?.postMessage(m, "*");
@@ -386,6 +418,19 @@ export function EditorView({ ops, registry, id }) {
         });
         mark();
     }, [mark]);
+    // A zone bound to a shared item needs the item's row id (ops.shared.list),
+    // which can land after the draft did. Fill then; nothing else changes.
+    useEffect(() => {
+        if (!tree || !sharedIds || !record)
+            return;
+        const template = registryRef.current.pages.find((p) => p.name === record.template);
+        const filled = fillLockedZones(tree, template?.zones ?? {}, registryRef.current.sections, sharedIds);
+        if (filled !== tree)
+            mutate(() => filled);
+        // `tree` is deliberately not a dependency: this runs when the ids land
+        // or a new draft loads, not on every keystroke.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sharedIds, record, mutate, tree === null]);
     // ── tree gestures ────────────────────────────────────────────────────
     const nodesIn = useCallback((zone) => tree?.zones[zone] ?? [], [tree]);
     const zoneCanTake = useCallback((zone) => canInsert(policyOf(zone), nodesIn(zone).length), [policyOf, nodesIn]);
@@ -395,6 +440,15 @@ export function EditorView({ ops, registry, id }) {
         setPicker(null);
         select(node.id);
     };
+    const doInsertShared = (zone, index, item) => {
+        const ref = sharedIds?.[item.name];
+        if (!ref)
+            return;
+        const node = placementNode(item, ref, newNodeId(SHARED_NODE_TYPE));
+        mutate((t) => insertNode(t, zone, index, node));
+        setPicker(null);
+        select(node.id);
+    };
     const doDuplicate = (node) => {
         if (!tree)
             return;
@@ -477,6 +531,7 @@ export function EditorView({ ops, registry, id }) {
     }
     const selected = tree && selectedId ? findNode(tree, selectedId) : null;
     const selectedSection = selected ? sectionOf(selected.type) : null;
+    const selectedShared = selected ? sharedOf(selected) : null;
     const selZone = tree && selected ? zoneOf(tree, selected.id) : null;
     const selLocked = policyOf(selZone)?.kind === "locked";
     const rectById = new Map(rects.map((r) => [r.id, r]));
@@ -534,12 +589,12 @@ export function EditorView({ ops, registry, id }) {
                                                         width: hoverRect.w, height: hoverRect.h,
                                                         outline: "1.5px solid color-mix(in srgb, var(--selection) 45%, transparent)",
                                                         outlineOffset: -1.5, borderRadius: "var(--radius-sm)",
-                                                    } })), selRect && selected && selectedSection && (_jsxs(_Fragment, { children: [_jsx("div", { style: {
+                                                    } })), selRect && selected && (selectedSection || selectedShared) && (_jsxs(_Fragment, { children: [_jsx("div", { style: {
                                                                 position: "absolute", left: selRect.x, top: selRect.y,
                                                                 width: selRect.w, height: selRect.h,
                                                                 outline: "var(--outline-selection)", outlineOffset: -1.5,
                                                                 borderRadius: "var(--radius-sm)",
-                                                            } }), _jsxs("span", { className: "sm-blocktag", style: { position: "absolute", left: selRect.x, top: selRect.y }, children: [selectedSection.title, selLocked && " · locked"] }), _jsx("div", { className: "sm-blocktoolbar", style: {
+                                                            } }), _jsxs("span", { className: "sm-blocktag", style: { position: "absolute", left: selRect.x, top: selRect.y }, children: [selectedSection?.title ?? selectedShared?.title, selectedShared && " · shared", selLocked && " · locked"] }), _jsx("div", { className: "sm-blocktoolbar", style: {
                                                                 position: "absolute", left: selRect.x + selRect.w - 8, top: selRect.y + 8,
                                                                 transform: "translateX(-100%)", pointerEvents: "auto",
                                                             }, children: selLocked ? (_jsx("span", { className: "sm-mono", style: { fontSize: "var(--text-xs)", color: "#8C94A8", padding: "4px 8px" }, children: "fields only" })) : (_jsxs(_Fragment, { children: [_jsx(IconButton, { label: "Move up", tone: "inverse", onClick: () => doMove(selected.id, -1), children: "\u2191" }), _jsx(IconButton, { label: "Move down", tone: "inverse", onClick: () => doMove(selected.id, 1), children: "\u2193" }), _jsx(IconButton, { label: "Duplicate", tone: "inverse", onClick: () => doDuplicate(selected), children: "\u29C9" }), _jsx(IconButton, { label: "Remove", tone: "inverse", onClick: () => doRemove(selected.id), children: "\u00D7" })] })) })] })), plusButtons.map((p) => {
@@ -550,11 +605,11 @@ export function EditorView({ ops, registry, id }) {
                                                                     display: "flex", flexDirection: "column", alignItems: "center", gap: 6,
                                                                     pointerEvents: "auto",
                                                                 }, children: [_jsx("button", { className: "sm-plus", "aria-label": `Add to ${p.zone}`, onMouseEnter: () => setHoverPlus(key), onMouseLeave: () => setHoverPlus((k) => (k === key ? null : k)), onClick: (e) => setPicker({ zone: p.zone, index: p.index, x: e.clientX - 150, y: e.clientY + 12 }), children: "+" }), hot && _jsxs("span", { className: "sm-tooltip", children: ["Add to ", p.zone] })] })] }, key));
-                                                })] })] }) })] }), _jsxs("aside", { className: "sm-inspector", children: [selected && selectedSection ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "sm-inspector__head", children: [_jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-blockglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: selectedSection.title })] }), _jsx(IconButton, { label: "Clear selection", onClick: () => setSelectedId(null), children: "\u00D7" })] }), tabs.length > 0 && (_jsx(Tabs, { tabs: tabs.map((t) => t.tab), value: activeTab, onChange: (t) => setTab(t) }))] })) : (_jsx("div", { className: "sm-inspector__head", children: _jsx("span", { className: "sm-label", children: "Nothing selected \u2014 page settings below" }) })), _jsxs("div", { className: "sm-inspector__body", children: [!selected && record && (_jsxs(_Fragment, { children: [_jsx(PageSettings, { record: record, locale: locale, registry: registry, path: paths[locale], fixed: isFixedNode(record, registry), onRename: onRename, onRemoveLocale: Object.keys(record.locales).length > 1 &&
+                                                })] })] }) })] }), _jsxs("aside", { className: "sm-inspector", children: [selected && (selectedSection || selectedShared) ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "sm-inspector__head", children: [_jsxs("span", { style: { display: "flex", alignItems: "center", gap: 8, minWidth: 0 }, children: [_jsx("span", { className: "sm-blockglyph" }), _jsx("span", { className: "sm-title", style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: selectedSection?.title ?? selectedShared?.title })] }), _jsx(IconButton, { label: "Clear selection", onClick: () => setSelectedId(null), children: "\u00D7" })] }), tabs.length > 0 && (_jsx(Tabs, { tabs: tabs.map((t) => t.tab), value: activeTab, onChange: (t) => setTab(t) }))] })) : (_jsx("div", { className: "sm-inspector__head", children: _jsx("span", { className: "sm-label", children: "Nothing selected \u2014 page settings below" }) })), _jsxs("div", { className: "sm-inspector__body", children: [!selected && record && (_jsxs(_Fragment, { children: [_jsx(PageSettings, { record: record, locale: locale, registry: registry, path: paths[locale], fixed: isFixedNode(record, registry), onRename: onRename, onRemoveLocale: Object.keys(record.locales).length > 1 &&
                                                     !isFixedNode(record, registry) &&
                                                     !(record.parentId === null && record.locales[registry.locales.default]?.slug === registry.homePageSlug)
                                                     ? () => { void doRemoveLocale(); }
-                                                    : undefined }), _jsx(Divider, { bleed: 14 })] })), selected && selectedSection && entries.map(({ key, ns, descriptor }) => (_jsx(FieldWidget, { fieldKey: key, descriptor: descriptor, value: selected[ns]?.[key], refOptions: refOptionsFor(refOptions, refTargets, selectedSection, ns, key, descriptor), onChange: (value) => doPatch(selected.id, ns, key, value) }, `${selected.id}.${ns}.${key}`))), _jsx(Divider, { bleed: 14 }), _jsx(SectionLabel, { children: "Outline" }), zoneOrder.map((zone) => {
+                                                    : undefined }), _jsx(Divider, { bleed: 14 })] })), selected && selectedSection && entries.map(({ key, ns, descriptor }) => (_jsx(FieldWidget, { fieldKey: key, descriptor: descriptor, value: selected[ns]?.[key], refOptions: refOptionsFor(refOptions, refTargets, selectedSection, ns, key, descriptor), onChange: (value) => doPatch(selected.id, ns, key, value) }, `${selected.id}.${ns}.${key}`))), selected && selectedShared && (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 10 }, children: [_jsx("p", { className: "sm-hint", children: "This is shared content. Editing it changes every page it is placed on." }), _jsx("a", { className: "sm-nav-item", href: `${BASE}/shared/${encodeURIComponent(selectedShared.name)}?locale=${encodeURIComponent(locale)}`, children: "Edit shared item \u2192" })] })), _jsx(Divider, { bleed: 14 }), _jsx(SectionLabel, { children: "Outline" }), zoneOrder.map((zone) => {
                                         const locked = policyOf(zone)?.kind === "locked";
                                         const nodes = nodesIn(zone);
                                         return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 4 }, children: [_jsxs(SectionLabel, { mono: true, children: [zone, locked && " · locked"] }), nodes.length === 0 && (_jsxs("div", { className: cx("sm-outline-row", "sm-outline-row--empty", zoneCanTake(zone) && "sm-outline-row--clickable"), onClick: () => {
@@ -567,15 +622,16 @@ export function EditorView({ ops, registry, id }) {
                                                     const section = sectionOf(node.type);
                                                     const isSelected = node.id === selectedId;
                                                     if (locked) {
-                                                        return (_jsxs("div", { className: "sm-outline-row sm-outline-row--locked sm-outline-row--clickable", onClick: () => select(node.id), children: [_jsx("span", { className: "sm-outline-row__label", children: section?.title ?? node.type }), _jsx("span", { style: { fontSize: "var(--text-xs)", fontWeight: 600, letterSpacing: ".06em" }, children: "LOCKED" })] }, node.id));
+                                                        return (_jsxs("div", { className: "sm-outline-row sm-outline-row--locked sm-outline-row--clickable", onClick: () => select(node.id), children: [_jsx("span", { className: "sm-outline-row__label", children: section?.title ?? (sharedOf(node) ? `${sharedOf(node).title} · shared` : node.type) }), _jsx("span", { style: { fontSize: "var(--text-xs)", fontWeight: 600, letterSpacing: ".06em" }, children: "LOCKED" })] }, node.id));
                                                     }
-                                                    return (_jsxs("div", { onClick: () => select(node.id), className: cx("sm-outline-row", "sm-outline-row--clickable", isSelected && "sm-outline-row--selected"), children: [_jsx("span", { className: "sm-outline-row__label", children: section?.title ?? node.type }), _jsxs("span", { style: { display: "flex", gap: 2, flex: "none" }, children: [_jsx(IconButton, { label: "Move up", size: 22, disabled: i === 0, onClick: (e) => { e.stopPropagation(); doMove(node.id, -1); }, children: "\u2191" }), _jsx(IconButton, { label: "Move down", size: 22, disabled: i === nodes.length - 1, onClick: (e) => { e.stopPropagation(); doMove(node.id, 1); }, children: "\u2193" }), _jsx(IconButton, { label: "Remove", size: 22, onClick: (e) => { e.stopPropagation(); doRemove(node.id); }, children: "\u00D7" })] })] }, node.id));
+                                                    return (_jsxs("div", { onClick: () => select(node.id), className: cx("sm-outline-row", "sm-outline-row--clickable", isSelected && "sm-outline-row--selected"), children: [_jsx("span", { className: "sm-outline-row__label", children: section?.title ?? (sharedOf(node) ? `${sharedOf(node).title} · shared` : node.type) }), _jsxs("span", { style: { display: "flex", gap: 2, flex: "none" }, children: [_jsx(IconButton, { label: "Move up", size: 22, disabled: i === 0, onClick: (e) => { e.stopPropagation(); doMove(node.id, -1); }, children: "\u2191" }), _jsx(IconButton, { label: "Move down", size: 22, disabled: i === nodes.length - 1, onClick: (e) => { e.stopPropagation(); doMove(node.id, 1); }, children: "\u2193" }), _jsx(IconButton, { label: "Remove", size: 22, onClick: (e) => { e.stopPropagation(); doRemove(node.id); }, children: "\u00D7" })] })] }, node.id));
                                                 })] }, zone));
                                     })] })] })] }), picker && (_jsx("div", { style: { position: "fixed", inset: 0, zIndex: 60 }, onClick: () => setPicker(null), children: _jsxs("div", { className: "sm-picker", onClick: (e) => e.stopPropagation(), style: {
                         position: "absolute",
                         left: Math.max(12, Math.min(picker.x, window.innerWidth - 320)),
                         top: Math.min(picker.y, Math.max(12, window.innerHeight - 240)),
-                    }, children: [_jsxs(SectionLabel, { mono: true, style: { padding: "6px 8px 8px" }, children: ["Add to ", picker.zone] }), allowedSections(policyOf(picker.zone), registry.sections).map((section) => (_jsxs("button", { type: "button", className: "sm-picker__item", onClick: () => doInsert(picker.zone, picker.index, section), children: [_jsx("span", { className: "sm-picker__icon", children: section.icon ?? "▤" }), _jsxs("span", { style: { minWidth: 0 }, children: [_jsx("span", { style: { display: "block", fontWeight: 600 }, children: section.title }), section.description && (_jsx("span", { style: { display: "block", fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: section.description }))] })] }, section.name))), allowedSections(policyOf(picker.zone), registry.sections).length === 0 && (_jsx("p", { style: { color: "var(--text-muted)", padding: 10 }, children: "This zone doesn't accept insertions." }))] }) }))] }));
+                    }, children: [_jsxs(SectionLabel, { mono: true, style: { padding: "6px 8px 8px" }, children: ["Add to ", picker.zone] }), allowedSections(policyOf(picker.zone), registry.sections).map((section) => (_jsxs("button", { type: "button", className: "sm-picker__item", onClick: () => doInsert(picker.zone, picker.index, section), children: [_jsx("span", { className: "sm-picker__icon", children: section.icon ?? "▤" }), _jsxs("span", { style: { minWidth: 0 }, children: [_jsx("span", { style: { display: "block", fontWeight: 600 }, children: section.title }), section.description && (_jsx("span", { style: { display: "block", fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: section.description }))] })] }, section.name))), allowedShared(policyOf(picker.zone), registry.shared, sharedIds ?? {}).length > 0 && (_jsxs(_Fragment, { children: [_jsx(SectionLabel, { mono: true, style: { padding: "8px 8px 4px" }, children: "Shared" }), allowedShared(policyOf(picker.zone), registry.shared, sharedIds ?? {}).map((item) => (_jsxs("button", { type: "button", className: "sm-picker__item", onClick: () => doInsertShared(picker.zone, picker.index, item), children: [_jsx("span", { className: "sm-picker__icon", children: "\u26D3" }), _jsxs("span", { style: { minWidth: 0 }, children: [_jsx("span", { style: { display: "block", fontWeight: 600 }, children: item.title }), _jsx("span", { style: { display: "block", fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: "Shared \u00B7 edited in one place" })] })] }, `shared-${item.name}`)))] })), allowedSections(policyOf(picker.zone), registry.sections).length === 0 &&
+                            allowedShared(policyOf(picker.zone), registry.shared, sharedIds ?? {}).length === 0 && (_jsx("p", { style: { color: "var(--text-muted)", padding: 10 }, children: "This zone doesn't accept insertions." }))] }) }))] }));
 }
 /** The selected node's ref field (if any) resolves to its target
  * collection's loaded options — the EntryForm shape, section-scoped. */

package/dist/admin/index.d.ts

@@ -1,11 +1,12 @@
-export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult } from "./ops.ts";
+export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, SharedListItem, SharedGetResult } from "./ops.ts";
 export { createAdminOps, runAdminOp, type AdminEffects } from "./ops-impl.ts";
 export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes, type FixedNode } from "./fixed-nodes.ts";
+export { ensureSharedItems, initialSharedFields } from "./shared-items.ts";
 export { makeClientOps } from "./client-ops.ts";
 export { gateAdminOp, type AdminAuth } from "./auth.ts";
 export { supabaseAdminAuth } from "./supabase-auth.ts";
 export { serializeAdminConfig } from "./serialize.ts";
-export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminField } from "./serialize.ts";
+export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminShared, AdminField } from "./serialize.ts";
 export * from "./tree-ops.ts";
 export { validateFields, type FieldError } from "./validate.ts";
 export { plainToRichtext, richtextToPlain } from "./richtext.ts";

package/dist/admin/index.js

@@ -1,5 +1,6 @@
 export { createAdminOps, runAdminOp } from "./ops-impl.js";
 export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes } from "./fixed-nodes.js";
+export { ensureSharedItems, initialSharedFields } from "./shared-items.js";
 export { makeClientOps } from "./client-ops.js";
 export { gateAdminOp } from "./auth.js";
 export { supabaseAdminAuth } from "./supabase-auth.js";

package/dist/admin/ops-impl.js

@@ -1,6 +1,7 @@
 import { entryFieldsIn } from "../entry-store.js";
-import { affectedTargets, entryTag, pageTag } from "../revalidate.js";
+import { affectedTargets, entryTag, pageTag, sharedTag } from "../revalidate.js";
 import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
+import { ensureSharedItems } from "./shared-items.js";
 import { validateFields } from "./validate.js";
 const ok = (data) => ({ ok: true, data });
 const err = (code, message, fields) => ({ ok: false, code, message, ...(fields ? { fields } : {}) });
@@ -43,6 +44,15 @@ const classify = (e) => {
     }
     if (message.includes("does not exist in locale"))
         return err("not_found", message);
+    if (message.includes("cannot take a slug"))
+        return err("validation", message);
+    // Ahead of the generic "already exists" check below: the singleton
+    // refusal's message ("...already exists — it is a singleton.") contains
+    // "already exists" as a substring, so it must classify here first or it
+    // would be misread as a plain conflict.
+    if (message.includes("is owned by code") || message.includes("it is a singleton") || message.includes("exists in every locale")) {
+        return err("blocked", message);
+    }
     if (message.includes("already exists"))
         return err("conflict", message);
     if (message.includes("is referenced by"))
@@ -75,6 +85,9 @@ export function createAdminOps(deps) {
     const href = deps.href ?? ((path) => path);
     const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
     const sectionFields = (type) => config.registry.sections?.find((s) => s.schema.name === type)?.schema;
+    const sharedItem = (name) => config.registry.shared?.find((s) => s.name === name) ?? null;
+    /** One row per registration; null when materialization could not create it. */
+    const sharedRecord = async (name) => (await entries.list(name))[0] ?? null;
     const fanOut = async (entryId) => {
         if (!effects?.revalidate)
             return;
@@ -83,6 +96,24 @@ export function createAdminOps(deps) {
             effects.revalidate(entryTag(id));
         for (const id of pageIds)
             effects.revalidate(pageTag(id));
+        // A shared item's row is an entry like any other: when the item
+        // itself changes OR when something it REFERENCES does, the unit
+        // `getSmoodlyShared` caches under `shared:<name>` is stale too — and
+        // that unit is a layout, on every page. `affectedTargets` returns row
+        // ids, so resolve name → row id here. Once per fan-out, not memoized
+        // per ops instance: a row can be materialized between two calls, and
+        // an entry write is rare enough that one `entries.list` per
+        // registration beats reasoning about a stale cache. Last, so the
+        // existing entry-then-page order is untouched.
+        const registered = config.registry.shared ?? [];
+        if (registered.length === 0)
+            return;
+        const touched = new Set(entryIds);
+        for (const item of registered) {
+            const row = (await entries.list(item.name))[0];
+            if (row && touched.has(row.id))
+                effects.revalidate(sharedTag(item.name));
+        }
     };
     /** Expire the cached units a tree change touched, in order, once each. */
     const expirePages = (ids) => {
@@ -404,6 +435,58 @@ export function createAdminOps(deps) {
                 return ok(entry);
             }),
         },
+        shared: {
+            list: () => guard(async () => {
+                const records = await ensureSharedItems(entries, config);
+                return ok((config.registry.shared ?? []).flatMap((s) => (records[s.name] ? [{ name: s.name, record: records[s.name] }] : [])));
+            }),
+            get: (name, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const item = sharedItem(name);
+                if (!item)
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                await ensureSharedItems(entries, config);
+                const record = await sharedRecord(name);
+                if (!record?.locales[locale])
+                    return err("not_found", `smoodly: shared item "${name}" does not exist in locale "${locale}".`);
+                const usage = await entries.referencesTo(name, record.id);
+                return ok({ name, record, locale, fields: entryFieldsIn(record, locale), usage });
+            }),
+            save: (name, locale, fields) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const item = sharedItem(name);
+                if (!item)
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const fieldErrors = validateFields(fields, item.fields);
+                if (fieldErrors.length > 0)
+                    return err("validation", "Some fields need attention.", fieldErrors);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                const saved = await entries.update(name, record.id, locale, fields);
+                // fanOut expires `shared:<name>` itself — this row IS the item's.
+                await fanOut(record.id);
+                return ok(saved);
+            }),
+            setStatus: (name, locale, status) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                if (!sharedItem(name))
+                    return err("not_found", `smoodly: no shared item named "${name}".`);
+                const record = await sharedRecord(name);
+                if (!record)
+                    return err("not_found", `smoodly: shared item "${name}" is not materialized — open Shared content first.`);
+                const changed = await entries.setStatus(name, record.id, locale, status);
+                // see save: the fan-out carries the item's own tag.
+                await fanOut(record.id);
+                return ok(changed);
+            }),
+        },
         preview: {
             enable: () => guard(async () => (await effects?.draft?.enable(), ok(null))),
             disable: () => guard(async () => (await effects?.draft?.disable(), ok(null))),

package/dist/admin/ops.d.ts

@@ -1,6 +1,6 @@
 import type { PageRecord } from "../store.ts";
 import type { PageTree } from "../render.tsx";
-import type { EntryRecord } from "../entry-store.ts";
+import type { EntryRecord, EntryUsage } from "../entry-store.ts";
 import type { FieldError } from "./validate.ts";
 export type OpError = {
     ok: false;
@@ -56,6 +56,20 @@ export type EntryGetResult = {
     /** The locales the PARENT exists in (every supported locale for a root) — the form disables the rest with a reason. */
     parentLocales: string[];
 };
+export type SharedListItem = {
+    name: string;
+    record: EntryRecord;
+};
+export type SharedGetResult = {
+    name: string;
+    /** The node with ALL its locale rows (every supported one, by construction). */
+    record: EntryRecord;
+    locale: string;
+    /** That locale's merged draft fields — a visual item's styles under `$styles`. */
+    fields: Record<string, unknown>;
+    /** Who links it: "used on N pages". */
+    usage: EntryUsage[];
+};
 export type AdminOps = {
     pages: {
         /** Lists every node, materializing fixed pages and collection mounts (in every supported locale) first. */
@@ -105,6 +119,13 @@ export type AdminOps = {
         /** Deletes the locale's row, versions and paths; fans out like a save. */
         removeLocale(collection: string, id: string, locale: string): Promise<OpResult<EntryRecord>>;
     };
+    shared: {
+        /** Materializes every registered item in every supported locale, then lists them in registry order. */
+        list(): Promise<OpResult<SharedListItem[]>>;
+        get(name: string, locale: string): Promise<OpResult<SharedGetResult>>;
+        save(name: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
+        setStatus(name: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
+    };
     preview: {
         enable(): Promise<OpResult<null>>;
         disable(): Promise<OpResult<null>>;

package/dist/admin/serialize.d.ts

@@ -33,10 +33,21 @@ export type AdminPageTemplate = {
     slugs?: Record<string, string>;
     zones: Record<string, ZonePolicy>;
 };
+export type AdminShared = {
+    name: string;
+    title: string;
+    /** The section a visual item renders through; absent = an object item. */
+    section?: string;
+    versions: boolean;
+    fields: Record<string, AdminField>;
+    /** Resolved (the config's standard set merged in) for a visual item; empty for an object item. */
+    styles: Record<string, AdminField>;
+};
 export type AdminRegistry = {
     sections: AdminSection[];
     collections: AdminCollection[];
     pages: AdminPageTemplate[];
+    shared: AdminShared[];
     locales: {
         default: string;
         supported: string[];

package/dist/admin/serialize.js

@@ -53,6 +53,14 @@ export function serializeAdminConfig(config) {
                 zones: p.zones ?? {},
             };
         }),
+        shared: (config.registry.shared ?? []).map((s) => ({
+            name: s.name,
+            title: s.title,
+            ...(s.section !== undefined ? { section: s.section } : {}),
+            versions: s.versions === true,
+            fields: serializeMap(s.fields),
+            styles: serializeMap(s.section !== undefined ? config.resolvedStyles(s.section) : {}),
+        })),
         locales: config.locales,
         homePageSlug: config.homePageSlug,
         pageDepth: config.pageDepth,

package/dist/admin/shared-items.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { Descriptor } from "../fields.ts";
+import type { EntryRecord, EntryStore } from "../entry-store.ts";
+import { type SharedSchema } from "../shared.ts";
+/** The merged fields a fresh item starts from: sampled field values, and
+ *  for a visual item `$styles` = the resolved style defaults with the
+ *  sample's style values on top. Unsampled fields stay absent. */
+export declare function initialSharedFields(item: SharedSchema, resolvedStyles: Record<string, Descriptor>): Record<string, unknown>;
+export declare function ensureSharedItems(entries: EntryStore, config: ResolvedConfig): Promise<Record<string, EntryRecord>>;

package/dist/admin/shared-items.js

@@ -0,0 +1,61 @@
+import { STYLES_KEY } from "../shared.js";
+/** The merged fields a fresh item starts from: sampled field values, and
+ *  for a visual item `$styles` = the resolved style defaults with the
+ *  sample's style values on top. Unsampled fields stay absent. */
+export function initialSharedFields(item, resolvedStyles) {
+    const out = {};
+    for (const key of Object.keys(item.fields)) {
+        const sampled = item.sample?.[key];
+        if (sampled !== undefined)
+            out[key] = sampled;
+    }
+    if (item.section !== undefined) {
+        const styles = {};
+        for (const [key, d] of Object.entries(resolvedStyles)) {
+            const value = item.sample?.[key] ?? d.default;
+            if (value !== undefined)
+                styles[key] = value;
+        }
+        out[STYLES_KEY] = styles;
+    }
+    return out;
+}
+export async function ensureSharedItems(entries, config) {
+    const { default: def, supported } = config.locales;
+    const out = {};
+    for (const item of config.registry.shared ?? []) {
+        let [record] = await entries.list(item.name);
+        if (!record) {
+            try {
+                const styles = item.section !== undefined ? config.resolvedStyles(item.section) : {};
+                record = await entries.create(item.name, initialSharedFields(item, styles), { locale: def });
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                // Another admin load won the create: read theirs. Anything else is
+                // worth saying out loud, and must not take the other items down.
+                if (message.includes("it is a singleton"))
+                    [record] = await entries.list(item.name);
+                else
+                    console.warn(`smoodly: could not materialize shared item "${item.name}": ${message}`);
+                if (!record)
+                    continue;
+            }
+        }
+        for (const locale of supported) {
+            if (record.locales[locale])
+                continue;
+            try {
+                record = await entries.addLocale(item.name, record.id, locale, { from: def });
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                if (!message.includes("already exists in locale")) {
+                    console.warn(`smoodly: could not materialize shared item "${item.name}" in "${locale}": ${message}`);
+                }
+            }
+        }
+        out[item.name] = record;
+    }
+    return out;
+}

package/dist/admin/shell/AdminApp.js

@@ -14,6 +14,8 @@ import { makeClientOps } from "../client-ops.js";
 import { PagesList } from "./PagesList.js";
 import { EntriesList } from "./EntriesList.js";
 import { EntryForm } from "./EntryForm.js";
+import { SharedList } from "./SharedList.js";
+import { SharedForm } from "./SharedForm.js";
 import { EditorView } from "../editor/EditorView.js";
 import { LoginView } from "./LoginView.js";
 import { useAdminSession } from "./session.js";
@@ -22,12 +24,12 @@ import { BASE } from "./base.js";
 import { ErrorPane } from "./ErrorPane.js";
 /** Nav items the registry can't produce yet: shown, disabled, so the shape
  *  of the product is visible — the same set the design system's SideNav has. */
-const PLANNED = ["Shared Content", "Media", "Settings"];
+const PLANNED = ["Media", "Settings"];
 function Nav({ registry, active, email, onSignOut }) {
     const item = (href, label, key) => (_jsx("a", { className: "sm-nav-item", href: href ?? undefined, "aria-disabled": href ? undefined : true, "aria-current": href && key === active ? "page" : undefined, children: label }, key));
     const name = email?.split("@")[0] ?? "Editor";
     const initials = name.slice(0, 2).toUpperCase();
-    return (_jsxs("nav", { className: "sm-nav", children: [_jsx(Logo, {}), _jsxs("div", { className: "sm-nav__list", children: [item(`${BASE}/pages`, "Pages", "pages"), registry.collections.map((c) => item(`${BASE}/${c.name}`, c.title, c.name)), PLANNED.map((label) => item(null, label, label))] }), _jsxs("div", { className: "sm-nav__foot", children: [_jsx(ThemeToggle, {}), _jsxs("div", { className: "sm-nav__user", children: [_jsx("span", { className: "sm-avatar", children: initials }), _jsxs("span", { style: { display: "flex", flexDirection: "column", minWidth: 0 }, children: [_jsx("span", { style: { fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: name }), _jsx("span", { style: { fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: "Editor" })] })] }), _jsx("button", { className: "sm-nav-item", onClick: onSignOut, style: { color: "var(--text-muted)" }, children: "Sign out" })] })] }));
+    return (_jsxs("nav", { className: "sm-nav", children: [_jsx(Logo, {}), _jsxs("div", { className: "sm-nav__list", children: [item(`${BASE}/pages`, "Pages", "pages"), registry.collections.map((c) => item(`${BASE}/${c.name}`, c.title, c.name)), registry.shared.length > 0 && item(`${BASE}/shared`, "Shared content", "shared"), PLANNED.map((label) => item(null, label, label))] }), _jsxs("div", { className: "sm-nav__foot", children: [_jsx(ThemeToggle, {}), _jsxs("div", { className: "sm-nav__user", children: [_jsx("span", { className: "sm-avatar", children: initials }), _jsxs("span", { style: { display: "flex", flexDirection: "column", minWidth: 0 }, children: [_jsx("span", { style: { fontWeight: 500, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: name }), _jsx("span", { style: { fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: "Editor" })] })] }), _jsx("button", { className: "sm-nav-item", onClick: onSignOut, style: { color: "var(--text-muted)" }, children: "Sign out" })] })] }));
 }
 export function AdminApp({ registry, segments, op, auth }) {
     const session = useAdminSession(auth);
@@ -49,6 +51,10 @@ export function AdminApp({ registry, segments, op, auth }) {
         main = _jsx(EntriesList, { ops: ops, registry: registry, collection: head });
     else if (isCollection && tail)
         main = _jsx(EntryForm, { ops: ops, registry: registry, collection: head, id: tail === "new" ? "new" : decodeURIComponent(tail) });
+    else if (head === "shared" && !tail)
+        main = _jsx(SharedList, { ops: ops, registry: registry });
+    else if (head === "shared" && tail)
+        main = _jsx(SharedForm, { ops: ops, registry: registry, name: decodeURIComponent(tail) });
     else
         main = _jsx(ErrorPane, { message: "Not found." });
     return (_jsxs("div", { className: "sm-shell", children: [_jsx(Nav, { registry: registry, active: head, email: email, onSignOut: () => session.client.auth.signOut() }), _jsx("main", { className: "sm-main", children: main })] }));