smoodly 0.0.7 → 0.0.8

package/dist/admin/shell/SharedForm.d.ts

@@ -0,0 +1,7 @@
+import type { AdminOps } from "../ops.ts";
+import type { AdminRegistry } from "../serialize.ts";
+export declare function SharedForm({ ops, registry, name }: {
+    ops: AdminOps;
+    registry: AdminRegistry;
+    name: string;
+}): import("react").JSX.Element;

package/dist/admin/shell/SharedForm.js

@@ -0,0 +1,146 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// One shared item, one locale (spec 2026-09-07 §6): the entry form's
+// shape without what a singleton never has — no slug, no "new", no
+// delete, no add/remove locale (every supported locale exists by
+// construction). Shared fields above, the locale's own below, and for a
+// visual item a Styles group edited under the reserved `$styles` key.
+// Status is per locale and immediate. "Used on N pages" is the refs
+// index's answer.
+import { useEffect, useMemo, useState } from "react";
+import { STYLES_KEY } from "../../shared.js";
+import { FieldWidget } from "../forms/FieldWidget.js";
+import { relativeTime } from "../ui/format.js";
+import { LocaleSwitcher } from "../ui/LocaleSwitcher.js";
+import { Banner, Breadcrumb, Button, Divider, SectionLabel, Segmented, TopBar } from "../ui/primitives.js";
+import { entryTitle } from "./entries-list.js";
+import { BASE } from "./base.js";
+const STATUSES = ["Draft", "Published"];
+function localeFromUrl(registry) {
+    try {
+        const l = new URLSearchParams(window.location.search).get("locale");
+        if (l && registry.locales.supported.includes(l))
+            return l;
+    }
+    catch {
+        // no window — the default is fine
+    }
+    return registry.locales.default;
+}
+function writeLocaleToUrl(next) {
+    try {
+        const u = new URL(window.location.href);
+        u.searchParams.set("locale", next);
+        window.history.replaceState(null, "", u);
+    }
+    catch {
+        // the URL is cosmetic here
+    }
+}
+export function SharedForm({ ops, registry, name }) {
+    const item = registry.shared.find((s) => s.name === name);
+    const multilingual = registry.locales.supported.length > 1;
+    const [locale, setLocale] = useState(() => localeFromUrl(registry));
+    const [record, setRecord] = useState(null);
+    const [fields, setFields] = useState(null);
+    const [usage, setUsage] = useState([]);
+    const [refOptions, setRefOptions] = useState({});
+    const [banner, setBanner] = useState(null);
+    const [fieldErrors, setFieldErrors] = useState({});
+    const [dirty, setDirty] = useState(false);
+    const refTargets = useMemo(() => {
+        const out = {};
+        for (const [key, d] of Object.entries(item?.fields ?? {})) {
+            if ((d.type === "ref" || d.type === "refList") && typeof d.target === "string")
+                out[key] = d.target;
+        }
+        return out;
+    }, [item]);
+    const localeKeys = useMemo(() => Object.entries(item?.fields ?? {}).filter(([, d]) => d.localized === true).map(([key]) => key), [item]);
+    useEffect(() => {
+        let cancelled = false;
+        setFields(null);
+        setFieldErrors({});
+        ops.shared.get(name, locale).then((r) => {
+            if (cancelled)
+                return;
+            if (r.ok) {
+                setRecord(r.data.record);
+                setFields(r.data.fields);
+                setUsage(r.data.usage);
+                setDirty(false);
+            }
+            else
+                setBanner({ tone: "error", text: r.message });
+        }).catch(() => { if (!cancelled)
+            setBanner({ tone: "error", text: "Couldn't reach the server." }); });
+        return () => { cancelled = true; };
+    }, [ops, name, locale]);
+    // Ref options in the locale being edited — the entry form's rule.
+    useEffect(() => {
+        let cancelled = false;
+        for (const target of new Set(Object.values(refTargets))) {
+            const targetMeta = registry.collections.find((c) => c.name === target);
+            ops.entries.list(target).then((r) => {
+                if (cancelled || !r.ok)
+                    return;
+                const options = r.data
+                    .filter((e) => e.locales[locale])
+                    .map((e) => ({ id: e.id, title: targetMeta ? entryTitle(e, targetMeta, registry, locale) : e.id, status: e.locales[locale].status }));
+                setRefOptions((prev) => ({ ...prev, [target]: options }));
+            }).catch(console.error);
+        }
+        return () => { cancelled = true; };
+    }, [ops, refTargets, registry, locale]);
+    if (!item)
+        return _jsx("p", { style: { padding: 32 }, children: "No such shared item." });
+    const applyResult = (r, okText) => {
+        if (r.ok) {
+            setBanner({ tone: "ok", text: okText });
+            setFieldErrors({});
+            return true;
+        }
+        setBanner({ tone: "error", text: r.message });
+        setFieldErrors(Object.fromEntries((r.fields ?? []).map((f) => [f.field, f.message])));
+        return false;
+    };
+    const save = async () => {
+        if (!fields)
+            return;
+        const r = await ops.shared.save(name, locale, fields);
+        if (applyResult(r, "Saved.") && r.ok) {
+            setRecord(r.data);
+            setDirty(false);
+        }
+    };
+    const row = record?.locales[locale];
+    const status = row?.status ?? "draft";
+    const setPublished = async (next) => {
+        if (next === status)
+            return;
+        const r = await ops.shared.setStatus(name, locale, next);
+        if (applyResult(r, next === "published" ? "Published." : "Unpublished.") && r.ok)
+            setRecord(r.data);
+    };
+    const switchLocale = (next) => {
+        if (next === locale)
+            return;
+        if (dirty && !window.confirm("Discard unsaved changes?"))
+            return;
+        writeLocaleToUrl(next);
+        setBanner(null);
+        setLocale(next);
+    };
+    const shared = Object.entries(item.fields).filter(([key]) => !localeKeys.includes(key));
+    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));
+    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);
+                                                } }, key)))] }))] })) : !banner && _jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" })] }), _jsxs("aside", { style: { display: "flex", flexDirection: "column", gap: 16, padding: "16px 14px", minHeight: 0, overflow: "auto", borderLeft: "var(--border)" }, children: [_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [_jsxs(SectionLabel, { children: ["Status", multilingual ? ` · ${locale}` : ""] }), _jsx(Segmented, { options: STATUSES, stretch: true, disabled: !row, value: status === "published" ? "Published" : "Draft", onChange: (v) => { void setPublished(v === "Published" ? "published" : "draft"); } })] }), record && row && (_jsxs(_Fragment, { children: [_jsx(Divider, { bleed: 14 }), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [_jsx(SectionLabel, { children: "Document info" }), _jsx(InfoRow, { label: "Kind", value: item.section !== undefined ? `Visual · ${item.section}` : "Fields" }), _jsx(InfoRow, { label: "Updated", value: relativeTime(row.updatedAt) }), _jsx(InfoRow, { label: "ID", value: record.id, mono: true })] })] }))] })] })] }));
+}
+function InfoRow({ label, value, mono }) {
+    return (_jsxs("div", { style: { display: "flex", justifyContent: "space-between", gap: 10, fontSize: "var(--text-sm)", color: "var(--text-muted)" }, children: [_jsx("span", { children: label }), _jsx("span", { style: { color: "var(--text)", fontFamily: mono ? "var(--font-mono)" : undefined, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }, children: value })] }));
+}

package/dist/admin/shell/SharedList.d.ts

@@ -0,0 +1,6 @@
+import type { AdminOps } from "../ops.ts";
+import type { AdminRegistry } from "../serialize.ts";
+export declare function SharedList({ ops, registry }: {
+    ops: AdminOps;
+    registry: AdminRegistry;
+}): import("react").JSX.Element;

package/dist/admin/shell/SharedList.js

@@ -0,0 +1,62 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// The Shared content list (spec 2026-09-07 §6): every registered item is
+// a row, edited on its own page. Nothing here is created or deleted by
+// editors — the registry declares the items and ops.shared.list
+// materializes them — so there is no "+ New".
+import { useCallback, useEffect, useState } from "react";
+import { ListView } from "./ListView.js";
+import { sharedRows } from "./shared-list.js";
+import { Segmented, StatusBadge } from "../ui/primitives.js";
+import { relativeTime } from "../ui/format.js";
+import { BASE } from "./base.js";
+import { ErrorPane } from "./ErrorPane.js";
+const LOCALE_KEY = "smoodly.entries.locale"; // the same choice the collection lists remember
+function rememberedLocale(registry) {
+    try {
+        const stored = window.sessionStorage.getItem(LOCALE_KEY);
+        if (stored && registry.locales.supported.includes(stored))
+            return stored;
+    }
+    catch {
+        // storage unavailable — the default is fine
+    }
+    return registry.locales.default;
+}
+export function SharedList({ ops, registry }) {
+    const [items, setItems] = useState(null);
+    const [error, setError] = useState(null);
+    const [locale, setLocale] = useState(() => rememberedLocale(registry));
+    const multilingual = registry.locales.supported.length > 1;
+    const pickLocale = (next) => {
+        setLocale(next);
+        try {
+            window.sessionStorage.setItem(LOCALE_KEY, next);
+        }
+        catch { /* see rememberedLocale */ }
+    };
+    const load = useCallback(() => {
+        ops.shared.list()
+            .then((r) => (r.ok ? setItems(r.data) : setError(r.message)))
+            .catch(() => setError("Couldn't reach the server."));
+    }, [ops]);
+    useEffect(load, [load]);
+    if (error)
+        return _jsx(ErrorPane, { message: error });
+    const rows = items ? sharedRows(items, registry, locale) : [];
+    return (_jsx(ListView, { title: "Shared content", count: items ? rows.length : undefined, actions: multilingual ? _jsx(Segmented, { options: registry.locales.supported, value: locale, onChange: pickLocale }) : undefined, columns: [
+            { label: "Title", width: "minmax(160px,1fr)" },
+            { label: "Kind", width: "90px" },
+            { label: "Updated", width: "minmax(110px,160px)" },
+            { label: "Status", width: "120px" },
+        ], empty: items ? "No shared content is registered." : "Loading…", rows: rows.map((row) => ({
+            key: row.name,
+            href: `${BASE}/shared/${encodeURIComponent(row.name)}?locale=${encodeURIComponent(locale)}`,
+            cells: [
+                _jsx("span", { className: "sm-cell sm-cell--title", children: row.title }, "t"),
+                _jsx("span", { className: "sm-cell sm-cell--muted", children: row.flavour }, "k"),
+                _jsx("span", { className: "sm-cell sm-cell--muted", children: relativeTime(row.updatedAt) }, "u"),
+                _jsx(StatusBadge, { status: row.status }, "s"),
+            ],
+        })) }));
+}

package/dist/admin/shell/shared-list.d.ts

@@ -0,0 +1,14 @@
+import type { EntryRecord } from "../../entry-store.ts";
+import type { AdminRegistry } from "../serialize.ts";
+import { type LocaleStatus } from "./pages-tree.ts";
+export type SharedRow = {
+    name: string;
+    title: string;
+    flavour: "Visual" | "Fields";
+    status: LocaleStatus;
+    updatedAt: number;
+};
+export declare function sharedRows(items: {
+    name: string;
+    record: EntryRecord;
+}[], registry: AdminRegistry, locale: string): SharedRow[];

package/dist/admin/shell/shared-list.js

@@ -0,0 +1,17 @@
+import { localeStatusOf } from "./pages-tree.js";
+export function sharedRows(items, registry, locale) {
+    const byName = new Map(items.map((i) => [i.name, i.record]));
+    return registry.shared.flatMap((item) => {
+        const record = byName.get(item.name);
+        const row = record?.locales[locale];
+        if (!record || !row)
+            return [];
+        return [{
+                name: item.name,
+                title: item.title,
+                flavour: item.section !== undefined ? "Visual" : "Fields",
+                status: localeStatusOf(row),
+                updatedAt: row.updatedAt,
+            }];
+    });
+}

package/dist/admin/tree-ops.d.ts

@@ -1,6 +1,6 @@
 import type { PageTree, TreeNode } from "../render.tsx";
 import type { ZonePolicy } from "../zones.ts";
-import type { AdminSection } from "./serialize.ts";
+import type { AdminSection, AdminShared } from "./serialize.ts";
 export declare function zoneOf(tree: PageTree, id: string): string | null;
 export declare function findNode(tree: PageTree, id: string): TreeNode | null;
 export declare function insertNode(tree: PageTree, zone: string, index: number, node: TreeNode): PageTree;
@@ -9,11 +9,18 @@ export declare function moveNode(tree: PageTree, id: string, dir: -1 | 1): PageT
 export declare function patchNode(tree: PageTree, id: string, ns: "fields" | "styles" | "meta", key: string, value: unknown): PageTree;
 export declare function canInsert(policy: ZonePolicy | undefined, count: number): boolean;
 export declare function allowedSections(policy: ZonePolicy | undefined, all: AdminSection[]): AdminSection[];
+/** The visual items the picker offers in a zone: materialized (an id is
+ *  known) and rendering a section the zone's policy allows. */
+export declare function allowedShared(policy: ZonePolicy | undefined, shared: AdminShared[], sharedIds: Record<string, string>): AdminShared[];
+/** A page places a visual item as this node (spec 2026-09-07 §6): `item`
+ *  names the registration, `ref` is the item's row id. */
+export declare function placementNode(item: AdminShared, ref: string, id: string): TreeNode;
 export declare function nodeFromSample(section: AdminSection, id: string): TreeNode;
 /** A locked zone holds exactly one node the editor can never insert or
  * remove — so someone has to put it there. This does, from the component's
- * sample, for every locked zone that is empty or missing. Runs when the
- * editor loads a draft, which also covers pages that predate a locked zone
- * being added to their schema. Returns the same tree when nothing changed. */
-export declare function fillLockedZones(tree: PageTree, policies: Record<string, ZonePolicy>, sections: AdminSection[]): PageTree;
+ * sample (or, for a zone bound to a shared item, a placement), for every
+ * locked zone that is empty or missing. Runs when the editor loads a draft,
+ * which also covers pages that predate a locked zone being added to their
+ * schema. Returns the same tree when nothing changed. */
+export declare function fillLockedZones(tree: PageTree, policies: Record<string, ZonePolicy>, sections: AdminSection[], sharedIds?: Record<string, string>): PageTree;
 export declare function newNodeId(type: string): string;

package/dist/admin/tree-ops.js

@@ -1,3 +1,4 @@
+import { SHARED_NODE_TYPE } from "../shared.js";
 export function zoneOf(tree, id) {
     for (const [zone, nodes] of Object.entries(tree.zones)) {
         if (nodes.some((n) => n.id === id))
@@ -60,6 +61,22 @@ export function allowedSections(policy, all) {
     const allow = new Set(policy.allow);
     return all.filter((s) => allow.has(s.name));
 }
+/** The visual items the picker offers in a zone: materialized (an id is
+ *  known) and rendering a section the zone's policy allows. */
+export function allowedShared(policy, shared, sharedIds) {
+    if (!policy || policy.kind === "locked")
+        return [];
+    return shared.filter((s) => {
+        if (s.section === undefined || sharedIds[s.name] === undefined)
+            return false;
+        return policy.allow === "*" || policy.allow.includes(s.section);
+    });
+}
+/** A page places a visual item as this node (spec 2026-09-07 §6): `item`
+ *  names the registration, `ref` is the item's row id. */
+export function placementNode(item, ref, id) {
+    return { id, type: SHARED_NODE_TYPE, fields: { item: item.name, ref } };
+}
 /** The empty value a fresh node's field starts at, by descriptor type.
  * Shape matters: a list-valued field seeded with "" is a type lie that
  * crashes the first section view that maps over it. */
@@ -89,21 +106,35 @@ export function nodeFromSample(section, id) {
 }
 /** A locked zone holds exactly one node the editor can never insert or
  * remove — so someone has to put it there. This does, from the component's
- * sample, for every locked zone that is empty or missing. Runs when the
- * editor loads a draft, which also covers pages that predate a locked zone
- * being added to their schema. Returns the same tree when nothing changed. */
-export function fillLockedZones(tree, policies, sections) {
+ * sample (or, for a zone bound to a shared item, a placement), for every
+ * locked zone that is empty or missing. Runs when the editor loads a draft,
+ * which also covers pages that predate a locked zone being added to their
+ * schema. Returns the same tree when nothing changed. */
+export function fillLockedZones(tree, policies, sections, sharedIds = {}) {
     let next = null;
     for (const [zone, policy] of Object.entries(policies)) {
         if (policy.kind !== "locked")
             continue;
         if ((tree.zones[zone] ?? []).length > 0)
             continue;
-        const section = sections.find((s) => s.name === policy.component);
-        if (!section)
-            continue;
+        let node = null;
+        if (policy.shared !== undefined) {
+            // Bound to a shared item (spec 2026-09-07 §4): a placement, once
+            // the editor has loaded the item's row id; until then leave the
+            // zone empty rather than seed a plain section there.
+            const ref = sharedIds[policy.shared];
+            if (ref === undefined)
+                continue;
+            node = placementNode({ name: policy.shared }, ref, newNodeId(SHARED_NODE_TYPE));
+        }
+        else {
+            const section = sections.find((s) => s.name === policy.component);
+            if (!section)
+                continue;
+            node = nodeFromSample(section, newNodeId(section.name));
+        }
         next ?? (next = { ...tree, zones: { ...tree.zones } });
-        next.zones[zone] = [nodeFromSample(section, newNodeId(section.name))];
+        next.zones[zone] = [node];
     }
     return next ?? tree;
 }

package/dist/collections.d.ts

@@ -9,7 +9,10 @@ export type EntryOrder = "manual" | {
 export declare const DEFAULT_ORDER: EntryOrder;
 export declare const BUILT_IN_ORDER_FIELDS: readonly ["createdAt", "updatedAt"];
 export type CollectionSchema<F extends BuilderMap = BuilderMap> = {
-    kind: "collection";
+    /** "shared" marks a code-declared singleton (spec 2026-09-07 decision
+     *  4): a shared item IS a collection with one entry, so both entry
+     *  stores accept it in the same list and branch on this. */
+    kind: "collection" | "shared";
     name: string;
     title: string;
     titleField?: string;

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { Descriptor, FieldBuilder } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
+import type { SharedSchema } from "./shared.ts";
 type Registered = {
     schema: {
         kind: string;
@@ -19,6 +20,8 @@ export type SmoodlyConfig = {
         collections?: CollectionSchema<any>[];
         /** Page shapes and entry pages alike — everything that renders a URL. */
         pages?: Registered[];
+        /** Shared content: code-declared singletons (spec 2026-09-07). */
+        shared?: SharedSchema[];
     };
     locales: {
         default: string;

package/dist/config.js

@@ -1,17 +1,50 @@
 import { assertSegment, fixedPageSegments, perLocaleSegments } from "./paths.js";
+const RESERVED_NAME = "shared"; // the placement node type and the admin route
 function assertUniqueNames(config) {
     const seen = new Set();
+    const sectionNameList = (config.registry.sections ?? []).map((s) => s.schema.name);
+    const sectionNames = new Set(sectionNameList);
     const all = [
-        ...(config.registry.sections ?? []).map((s) => s.schema.name),
+        ...sectionNameList,
         ...(config.registry.elements ?? []).map((e) => e.schema.name),
         ...(config.registry.collections ?? []).map((c) => c.name),
         ...(config.registry.pages ?? []).filter((p) => p.schema.kind !== "entryPage").map((p) => p.schema.name),
     ];
     for (const name of all) {
+        if (name === RESERVED_NAME)
+            throw new Error(`smoodly: "${RESERVED_NAME}" is a reserved name.`);
         if (seen.has(name))
             throw new Error(`smoodly: duplicate registered name "${name}".`);
         seen.add(name);
     }
+    // Shared items get their own pass, after every other kind is settled: a
+    // shared item's name must be unique among shared items, and must not
+    // collide with any collection/element/page/section name above — EXCEPT a
+    // visual item may reuse the name of the registered section it renders
+    // (spec 2026-09-07 §2's example pairs a "footer" section with a "footer"
+    // item). That exemption is narrow: it only excuses a match against the
+    // item's own, actually-registered section — never against a collection,
+    // element, or page that happens to share the string, and never against a
+    // second shared item of the same name.
+    const sharedSeen = new Set();
+    for (const item of config.registry.shared ?? []) {
+        const ownSection = item.name === item.section && sectionNames.has(item.name);
+        if (item.name === RESERVED_NAME)
+            throw new Error(`smoodly: "${RESERVED_NAME}" is a reserved name.`);
+        if (sharedSeen.has(item.name) || (seen.has(item.name) && !ownSection)) {
+            throw new Error(`smoodly: duplicate registered name "${item.name}".`);
+        }
+        sharedSeen.add(item.name);
+    }
+}
+/** A visual item renders through a registered section. */
+function assertSharedSections(config) {
+    const sections = new Set((config.registry.sections ?? []).map((s) => s.schema.name));
+    for (const item of config.registry.shared ?? []) {
+        if (item.section !== undefined && !sections.has(item.section)) {
+            throw new Error(`smoodly: shared item "${item.name}" renders section "${item.section}", which is not registered.`);
+        }
+    }
 }
 /** Every root-level segment a registration claims, per locale: fixed page
  *  slugs and collection paths. Two claims on one (locale, segment) are a
@@ -91,6 +124,7 @@ function assertLocales(config) {
 export function defineConfig(config) {
     assertLocales(config);
     assertUniqueNames(config);
+    assertSharedSections(config);
     assertRootSegments(config);
     const depth = config.pages?.tree?.depth ?? 1;
     if (!Number.isInteger(depth) || depth < 1)

package/dist/entry-store.d.ts

@@ -1,4 +1,5 @@
 import type { CollectionSchema, EntryOrder } from "./collections.ts";
+import type { SharedSchema } from "./shared.ts";
 import { type RefEdge } from "./refs.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
@@ -61,6 +62,7 @@ export type AddEntryLocaleOptions = {
 export type EntryStoreOptions = {
     paths?: PathIndex;
     locales?: LocaleSet;
+    shared?: SharedSchema[];
 };
 export interface EntryStore {
     /** Creates the node and ONE locale row from the merged `fields`: shared
@@ -118,6 +120,8 @@ export interface EntryStore {
     pathsOf(collection: string, id: string): Promise<Record<string, string>>;
 }
 export declare function schemaOf(collections: CollectionSchema<any>[], name: string): CollectionSchema<any>;
+/** A shared item is a collection with exactly one entry (spec 2026-09-07). */
+export declare const isSharedSchema: (schema: CollectionSchema<any>) => boolean;
 export declare const DEFAULT_ENTRY_LOCALES: LocaleSet;
 export declare const entryErrors: {
     notFound: (collection: string, id: string) => Error;
@@ -135,6 +139,10 @@ export declare const entryErrors: {
     lastLocale: (id: string) => Error;
     localeInUse: (locale: string, titles: string[]) => Error;
     moveLocales: (locale: string) => Error;
+    singleton: (name: string) => Error;
+    owned: (name: string, verb: string) => Error;
+    noSlug: (name: string) => Error;
+    everyLocale: (name: string) => Error;
 };
 /** The keys a locale row owns: every field with .localized(), except
  *  `slug`, which is the row's own column (a segment is an address, per
@@ -174,7 +182,6 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  */
 export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
 export declare class MemoryEntryStore implements EntryStore {
-    private collections;
     private refs;
     private entries;
     private versions;
@@ -184,6 +191,7 @@ export declare class MemoryEntryStore implements EntryStore {
     private order;
     private paths;
     private locales;
+    private schemas;
     constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex, options?: EntryStoreOptions);
     private schema;
     private row;

package/dist/entry-store.js

@@ -20,6 +20,8 @@ export function schemaOf(collections, name) {
         throw new Error(`smoodly: no collection named "${name}".`);
     return schema;
 }
+/** A shared item is a collection with exactly one entry (spec 2026-09-07). */
+export const isSharedSchema = (schema) => schema.kind === "shared";
 let counter = 0;
 const uid = (prefix) => `${prefix}-${++counter}-${Date.now().toString(36)}`;
 export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
@@ -39,6 +41,11 @@ export const entryErrors = {
     lastLocale: (id) => new Error(`smoodly: entry "${id}" must exist in at least one locale — delete the entry instead.`),
     localeInUse: (locale, titles) => new Error(`smoodly: child entries still exist in locale "${locale}" — remove it from ${titles.map((t) => `"${t}"`).join(", ")} first.`),
     moveLocales: (locale) => new Error(`smoodly: the destination parent does not exist in locale "${locale}" — the entry cannot move under it.`),
+    // Shared items (spec 2026-09-07 §3): one row, no URL, every locale, code-owned.
+    singleton: (name) => new Error(`smoodly: shared item "${name}" already exists — it is a singleton.`),
+    owned: (name, verb) => new Error(`smoodly: shared item "${name}" is owned by code — ${verb}.`),
+    noSlug: (name) => new Error(`smoodly: shared item "${name}" has no URL — it cannot take a slug.`),
+    everyLocale: (name) => new Error(`smoodly: shared item "${name}" exists in every locale — it cannot be removed from one.`),
 };
 /** The keys a locale row owns: every field with .localized(), except
  *  `slug`, which is the row's own column (a segment is an address, per
@@ -128,7 +135,6 @@ export class MemoryEntryStore {
     constructor(collections, 
     // pass the SAME index to MemoryPageStore so cross-kind questions work
     refs = new MemoryRefIndex(), options = {}) {
-        this.collections = collections;
         this.refs = refs;
         this.entries = new Map();
         this.versions = new Map();
@@ -139,9 +145,10 @@ export class MemoryEntryStore {
         this.byId = (id) => this.entries.get(id);
         this.paths = options.paths ?? new MemoryPathIndex();
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
+        this.schemas = [...collections, ...(options.shared ?? [])];
     }
     schema(collection) {
-        return schemaOf(this.collections, collection);
+        return schemaOf(this.schemas, collection);
     }
     row(collection, id) {
         const entry = this.entries.get(id);
@@ -253,6 +260,12 @@ export class MemoryEntryStore {
         const schema = this.schema(collection);
         assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
+        if (isSharedSchema(schema)) {
+            if ([...this.entries.values()].some((e) => e.collection === collection))
+                throw entryErrors.singleton(collection);
+            if (slugOf(fields) !== null)
+                throw entryErrors.noSlug(collection);
+        }
         const parent = this.assertParent(collection, parentId, 1);
         this.assertParentHasLocale(parent, options.locale);
         const { shared, localized, slug } = splitFields(fields, schema);
@@ -322,6 +335,8 @@ export class MemoryEntryStore {
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
+        if (isSharedSchema(schema) && slug !== null)
+            throw entryErrors.noSlug(collection);
         this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
         const before = { fields: entry.fields, row: { ...row } };
         entry.fields = shared;
@@ -387,6 +402,8 @@ export class MemoryEntryStore {
     }
     async removeLocale(collection, id, locale) {
         const schema = this.schema(collection);
+        if (isSharedSchema(schema))
+            throw entryErrors.everyLocale(collection);
         const entry = this.must(collection, id);
         const row = entryLocaleRow(entry, locale);
         if (Object.keys(entry.locales).length === 1)
@@ -417,6 +434,8 @@ export class MemoryEntryStore {
             .map((v) => structuredClone(v));
     }
     async move(collection, id, to) {
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "it has no tree position");
         const entry = this.must(collection, id);
         const subtree = this.subtree(entry);
         if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
@@ -454,6 +473,8 @@ export class MemoryEntryStore {
         const entry = this.row(collection, id);
         if (!entry)
             return;
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "remove the registration to remove it");
         if ([...this.entries.values()].some((e) => e.parentId === id))
             throw entryErrors.hasChildren(collection, id);
         const usage = await this.referencesTo(collection, id);
@@ -467,7 +488,8 @@ export class MemoryEntryStore {
         this.refs.remove({ sourceKind: "entry", sourceId: id });
     }
     async reorder(collection, orderedIds) {
-        this.schema(collection);
+        if (isSharedSchema(this.schema(collection)))
+            throw entryErrors.owned(collection, "it has no order");
         orderedIds.forEach((id, i) => {
             const entry = this.row(collection, id);
             if (entry)

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { collection, toolset } from "./collections.ts";
 import { Section } from "./section-wrapper.tsx";
 import { page } from "./render.tsx";
 import { entryPage } from "./entry-page.tsx";
+import { shared } from "./shared.ts";
 export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.tsx";
 export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageLink, PageViewProps } from "./render.tsx";
 export type { PageSchema } from "./page.ts";
@@ -24,7 +25,7 @@ export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
 export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, } from "./entry-store.ts";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, } from "./entry-store.ts";
-export { affectedTargets, pageTag, entryTag } from "./revalidate.ts";
+export { affectedTargets, pageTag, entryTag, sharedTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions } from "./resolve.ts";
@@ -40,6 +41,8 @@ export type { Props, PairedComponent } from "./pairing.tsx";
 export type { CollectionSchema, Toolset, EntryOrder } from "./collections.ts";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.ts";
 export type { ZonePolicy } from "./zones.ts";
+export { SHARED_NODE_TYPE, STYLES_KEY, sharedLink } from "./shared.ts";
+export type { SharedSchema, SharedLink } from "./shared.ts";
 export declare const smoodly: {
     schema: {
         page: typeof import("./page.ts").pageSchema;
@@ -110,6 +113,7 @@ export declare const smoodly: {
     entryPage: typeof entryPage;
     collection: typeof collection;
     toolset: typeof toolset;
+    shared: typeof shared;
     Section: typeof Section;
 };
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.ts";