smoodly 0.0.7 → 0.0.9

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/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/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;
@@ -33,10 +37,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

@@ -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;
         }
@@ -53,6 +56,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 })] }));

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.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;