smoodly 0.0.6 → 0.0.8

package/dist/admin/fixed-nodes.js

@@ -1,25 +1,19 @@
-import { perLocaleSegments } from "../paths.js";
+import { fixedPageSegments, perLocaleSegments } from "../paths.js";
 export function fixedNodeSpecs(config) {
     const { default: def, supported } = config.locales;
     const perLocale = (v) => perLocaleSegments(v, supported);
-    const i18nOf = (segments) => {
-        const out = {};
-        for (const [locale, segment] of Object.entries(segments)) {
-            if (locale !== def && segment !== segments[def])
-                out[locale] = { slug: segment };
-        }
-        return Object.keys(out).length > 0 ? out : null;
-    };
     const specs = new Map();
     for (const p of config.registry.pages ?? []) {
         if (p.schema.kind !== "page" || p.schema.slug === undefined)
             continue;
-        const segments = perLocale(p.schema.slug);
+        // Fixed pages exist in every supported locale (spec 2026-09-06 §3): a
+        // slug map that omits a locale falls back to the default locale's
+        // segment. One helper fills it for the boot check (config.ts), here
+        // and fixedPathFor (localize.ts), so the three cannot drift.
+        const segments = fixedPageSegments(p.schema.slug, config.locales);
         specs.set(segments[def], {
-            slug: segments[def],
-            i18n: i18nOf(segments),
+            segments,
             title: p.schema.title ?? p.schema.name,
-            locales: null,
             template: p.schema.name,
             collection: null,
         });
@@ -35,46 +29,66 @@ export function fixedNodeSpecs(config) {
             indexPage.collection = c.name;
             continue;
         }
-        specs.set(segments[def], {
-            slug: segments[def],
-            i18n: i18nOf(segments),
-            title: c.title,
-            locales: typeof c.path === "string" ? null : Object.keys(segments),
-            template: null,
-            collection: c.name,
-        });
+        specs.set(segments[def], { segments, title: c.title, template: null, collection: c.name });
     }
     return [...specs.values()];
 }
-/** The spec a ROOT record materializes, or null for an editor-owned node. */
+/** The spec a ROOT record materializes, or null for an editor-owned node.
+ *  Judged by the default-locale slug only — a root that exists in Finnish
+ *  alone is never a fixed node, whatever its Finnish slug. */
 export function fixedNodeOf(record, config) {
     if (record.parentId !== null)
         return null;
-    return fixedNodeSpecs(config).find((s) => s.slug === record.slug) ?? null;
+    const def = config.locales.default;
+    const slug = record.locales[def]?.slug;
+    if (slug === undefined)
+        return null;
+    return fixedNodeSpecs(config).find((s) => s.segments[def] === slug) ?? null;
 }
-/** Create every fixed node that has no root record yet, then list. */
+/** Create every fixed node that has no root record yet, give every fixed
+ *  node the locales it lacks, then list. */
 export async function ensureFixedNodes(pages, config) {
+    const def = config.locales.default;
     const all = await pages.listPages();
-    const taken = new Set(all.filter((p) => p.parentId === null).map((p) => p.slug));
+    const roots = all.filter((p) => p.parentId === null);
     let attempted = false;
     for (const spec of fixedNodeSpecs(config)) {
-        if (taken.has(spec.slug))
-            continue;
-        attempted = true;
-        try {
-            await pages.createPage({
-                slug: spec.slug, template: spec.template, title: spec.title, i18n: spec.i18n, locales: spec.locales,
-            });
+        const slug = spec.segments[def];
+        let record = roots.find((p) => p.locales[def]?.slug === slug);
+        if (!record) {
+            attempted = true;
+            try {
+                record = await pages.createPage({ locale: def, slug, template: spec.template, title: spec.title });
+            }
+            catch (e) {
+                // Two admins loading at once race on this very create; the loser's
+                // slugTaken is the other one winning, not a failure, so it skips
+                // silently — no warn. Anything else is worth saying out loud.
+                const message = e instanceof Error ? e.message : String(e);
+                if (!message.includes("already exists")) {
+                    console.warn(`smoodly: could not materialize "${slug}": ${message}`);
+                }
+                continue;
+            }
         }
-        catch (e) {
-            // One spec that cannot land — a path an editor already claimed in some
-            // locale — must not take the whole list down: warn, skip it, keep
-            // materializing the rest. Two admins loading at once can also race on
-            // this same create; the loser's slugTaken is the other one winning,
-            // not a failure, so it skips silently — no warn.
-            const message = e instanceof Error ? e.message : String(e);
-            if (!message.includes("already exists")) {
-                console.warn(`smoodly: could not materialize "${spec.slug}": ${message}`);
+        // Every locale the registration names — including one added to the
+        // config after the record was first materialized.
+        for (const [locale, segment] of Object.entries(spec.segments)) {
+            if (record.locales[locale])
+                continue;
+            attempted = true;
+            try {
+                record = await pages.addLocale(record.id, locale, { from: def, slug: segment });
+            }
+            catch (e) {
+                // One locale's row that cannot land — a segment or path an editor
+                // already claimed there — must not take the node or the whole list
+                // down: warn, skip that locale, keep materializing the rest. Only a
+                // concurrent add of the SAME locale is a race, and it skips silently.
+                const message = e instanceof Error ? e.message : String(e);
+                if (!message.includes("already exists in locale")) {
+                    console.warn(`smoodly: could not materialize "${slug}" in "${locale}": ${message}`);
+                }
             }
         }
     }

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,5 +1,7 @@
-import { affectedTargets, entryTag, pageTag } from "../revalidate.js";
+import { entryFieldsIn } from "../entry-store.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 } : {}) });
@@ -30,6 +32,27 @@ function isPageTree(tree) {
 /** Store throws are stringly-typed; classify the known guards, default to internal. */
 const classify = (e) => {
     const message = e instanceof Error ? e.message : String(e);
+    if (message.includes("already exists in locale"))
+        return err("conflict", message);
+    if (message.includes("not a supported locale"))
+        return err("validation", message);
+    if (message.includes("add it there first") ||
+        message.includes("remove it from") ||
+        message.includes("at least one locale") ||
+        message.includes("cannot move under it")) {
+        return err("blocked", message);
+    }
+    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"))
@@ -62,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;
@@ -70,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) => {
@@ -100,15 +144,22 @@ export function createAdminOps(deps) {
         }
         return out;
     };
-    const owned = (record, verb) => err("blocked", `smoodly: "${record.slug}" is owned by code — ${verb}.`);
+    const def = config.locales.default;
+    /** The name messages use for a node: its default-locale slug, else any locale's, else the id. */
+    const nameOf = (r) => r.locales[def]?.slug ?? Object.values(r.locales)[0]?.slug ?? r.id;
+    const owned = (record, verb) => err("blocked", `smoodly: "${nameOf(record)}" is owned by code — ${verb}.`);
     /** The record serving "/" — guarded whether or not a registration claims
-     *  its slug: the config's homePageSlug is what routes it. */
-    const isHomeNode = (r) => r.parentId === null && r.slug === config.homePageSlug;
+     *  its slug: the config's homePageSlug is what routes it. Judged by the
+     *  DEFAULT locale's slug (paths.ts isHomeNode, the same rule). */
+    const isHomeNode = (r) => r.parentId === null && r.locales[def]?.slug === config.homePageSlug;
+    const supportedLocale = (locale) => typeof locale === "string" && config.locales.supported.includes(locale)
+        ? null
+        : err("validation", `smoodly: "${String(locale)}" is not a supported locale.`);
     const openTemplate = (name) => config.registry.pages?.find((p) => p.schema.kind === "page" && p.schema.name === name);
     const mountGuard = (parent) => {
         const fixed = fixedNodeOf(parent, config);
         return fixed?.collection
-            ? err("blocked", `smoodly: pages cannot be created under "${parent.slug}" — the "${fixed.collection}" collection owns that URL space.`)
+            ? err("blocked", `smoodly: pages cannot be created under "${nameOf(parent)}" — the "${fixed.collection}" collection owns that URL space.`)
             : null;
     };
     const guard = async (work) => {
@@ -122,16 +173,27 @@ export function createAdminOps(deps) {
     return {
         pages: {
             list: () => guard(async () => ok(await ensureFixedNodes(pages, config))),
-            get: (id) => guard(async () => {
+            get: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
-                const draft = record.template === null ? null : await pages.getDraftTree(id);
+                const draft = record.template === null || !record.locales[locale] ? null : await pages.getDraftTree(id, locale);
                 const paths = await pages.pathsOf(id);
-                const urls = Object.fromEntries(Object.entries(paths).map(([locale, path]) => [locale, href(path, locale)]));
-                return ok({ record, draft, paths, urls });
+                const urls = Object.fromEntries(Object.entries(paths).map(([l, path]) => [l, href(path, l)]));
+                // A locale can only be added where the parent already has it; a
+                // root has no parent, so every supported locale is open.
+                const parentLocales = record.parentId === null
+                    ? config.locales.supported
+                    : Object.keys((await pages.getPage(record.parentId))?.locales ?? {});
+                return ok({ record, locale, draft, paths, urls, parentLocales });
             }),
             create: (input) => guard(async () => {
+                const unsupported = supportedLocale(input.locale);
+                if (unsupported)
+                    return unsupported;
                 if (input.template !== null) {
                     const registration = openTemplate(input.template);
                     if (!registration)
@@ -153,26 +215,35 @@ export function createAdminOps(deps) {
                     await ensureFixedNodes(pages, config);
                 }
                 return ok(await pages.createPage({
-                    slug: input.slug, template: input.template, parentId: input.parentId,
+                    locale: input.locale, slug: input.slug, template: input.template, parentId: input.parentId,
                     ...(input.title !== undefined ? { title: input.title } : {}),
                 }));
             }),
-            saveDraft: (id, tree) => guard(async () => {
+            saveDraft: (id, locale, tree) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
                 if (!isPageTree(tree))
                     return err("validation", "smoodly: malformed page tree.");
                 if (!(await pages.getPage(id)))
                     return err("not_found", `smoodly: no page "${id}".`);
-                return ok({ versionId: (await pages.saveDraft(id, tree)).id });
+                return ok({ versionId: (await pages.saveDraft(id, locale, tree)).id });
             }),
-            publish: (id) => guard(async () => {
+            publish: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
                 const record = await pages.getPage(id);
                 if (!record)
                     return err("not_found", `smoodly: no page "${id}".`);
-                const draft = record.template === null ? null : await pages.getDraftTree(id);
+                const row = record.locales[locale];
+                if (!row)
+                    return err("not_found", `smoodly: page "${id}" does not exist in locale "${locale}".`);
+                const draft = record.template === null ? null : await pages.getDraftTree(id, locale);
                 if (!draft) {
                     return record.template === null
-                        ? err("blocked", `smoodly: "${record.slug}" is a folder — give it a template first.`)
-                        : err("blocked", `smoodly: "${record.slug}" has no draft to publish.`);
+                        ? err("blocked", `smoodly: "${nameOf(record)}" is a folder — give it a template first.`)
+                        : err("blocked", `smoodly: "${row.slug}" has no draft to publish.`);
                 }
                 const fieldErrors = [];
                 for (const nodes of Object.values(draft.zones)) {
@@ -186,9 +257,9 @@ export function createAdminOps(deps) {
                     }
                 }
                 if (fieldErrors.length > 0) {
-                    return err("validation", `smoodly: cannot publish "${record.slug}" — fix the listed fields first.`, fieldErrors);
+                    return err("validation", `smoodly: cannot publish "${row.slug}" — fix the listed fields first.`, fieldErrors);
                 }
-                const published = await pages.publish(id);
+                const published = await pages.publish(id, locale);
                 // The parent's cached unit lists its published children.
                 expirePages([published.id, published.parentId]);
                 return ok(published);
@@ -198,10 +269,10 @@ export function createAdminOps(deps) {
                 if (!record)
                     return ok(null); // nothing to delete is not a failure
                 if (fixedNodeOf(record, config)) {
-                    return err("blocked", `smoodly: "${record.slug}" is owned by code — remove the registration to remove it.`);
+                    return err("blocked", `smoodly: "${nameOf(record)}" is owned by code — remove the registration to remove it.`);
                 }
                 if (isHomeNode(record))
-                    return err("blocked", `smoodly: "${record.slug}" is the site root — it cannot be deleted.`);
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the site root — it cannot be deleted.`);
                 await pages.deletePage(id);
                 // The cached unit is keyed by (locale, path) but tagged by the id
                 // found at the first miss; the parent's unit lists its children.
@@ -215,11 +286,11 @@ export function createAdminOps(deps) {
                 if (fixedNodeOf(record, config))
                     return owned(record, "rename it in the registration");
                 if (isHomeNode(record) && patch.slug !== undefined) {
-                    return err("blocked", `smoodly: "${record.slug}" is the site root — its slug is the config's homePageSlug.`);
-                }
-                if (!config.locales.supported.includes(patch.locale)) {
-                    return err("validation", `smoodly: "${patch.locale}" is not a supported locale.`);
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the site root — its slug is the config's homePageSlug.`);
                 }
+                const unsupported = supportedLocale(patch.locale);
+                if (unsupported)
+                    return unsupported;
                 const renamed = await pages.rename(id, patch);
                 // Every descendant's path changed with this segment; the parent
                 // lists this node's title and path.
@@ -233,7 +304,7 @@ export function createAdminOps(deps) {
                 if (fixedNodeOf(record, config))
                     return owned(record, "it stays at the root");
                 if (isHomeNode(record))
-                    return err("blocked", `smoodly: "${record.slug}" is the site root — it stays at the root.`);
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the site root — it stays at the root.`);
                 if (to.parentId !== null) {
                     const parent = await pages.getPage(to.parentId);
                     if (!parent)
@@ -252,7 +323,7 @@ export function createAdminOps(deps) {
                     return err("not_found", `smoodly: no page "${id}".`);
                 const fixed = fixedNodeOf(record, config);
                 if (fixed?.collection) {
-                    return err("blocked", `smoodly: "${record.slug}" is the "${fixed.collection}" collection's mount — its index page is a fixed registration.`);
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the "${fixed.collection}" collection's mount — its index page is a fixed registration.`);
                 }
                 const registration = openTemplate(template);
                 if (!registration)
@@ -262,35 +333,79 @@ export function createAdminOps(deps) {
                 }
                 return ok(await pages.setTemplate(id, template));
             }),
+            addLocale: (id, locale, options) => guard(async () => {
+                const unsupported = supportedLocale(locale) ?? supportedLocale(options?.from);
+                if (unsupported)
+                    return unsupported;
+                if (!(await pages.getPage(id)))
+                    return err("not_found", `smoodly: no page "${id}".`);
+                // A new locale is a draft: nothing public changes, nothing to expire.
+                return ok(await pages.addLocale(id, locale, { from: options.from }));
+            }),
+            removeLocale: (id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const record = await pages.getPage(id);
+                if (!record)
+                    return err("not_found", `smoodly: no page "${id}".`);
+                if (fixedNodeOf(record, config))
+                    return owned(record, "it exists in every locale");
+                if (isHomeNode(record))
+                    return err("blocked", `smoodly: "${nameOf(record)}" is the site root — it exists in every locale.`);
+                const removed = await pages.removeLocale(id, locale);
+                // The locale may have been published: its unit and the parent's listing go.
+                expirePages([id, record.parentId]);
+                return ok(removed);
+            }),
         },
         entries: {
             list: (collection) => guard(async () => ok(await entries.list(collection))),
-            get: (collection, id) => guard(async () => {
-                const entry = await entries.get(collection, id);
-                return entry ? ok(entry) : err("not_found", `smoodly: no entry "${id}" in "${collection}".`);
+            get: (collection, id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const record = await entries.get(collection, id);
+                if (!record)
+                    return err("not_found", `smoodly: no entry "${id}" in "${collection}".`);
+                const fields = record.locales[locale] ? entryFieldsIn(record, locale) : null;
+                // A locale can only be added where the parent already has it; a root has no parent.
+                const parentLocales = record.parentId === null
+                    ? config.locales.supported
+                    : Object.keys((await entries.get(collection, record.parentId))?.locales ?? {});
+                return ok({ record, locale, fields, parentLocales });
             }),
-            create: (collection, fields) => guard(async () => {
+            create: (collection, input) => guard(async () => {
+                const unsupported = supportedLocale(input.locale);
+                if (unsupported)
+                    return unsupported;
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const fieldErrors = validateFields(fields, descriptors);
+                const fieldErrors = validateFields(input.fields, descriptors);
                 if (fieldErrors.length > 0)
                     return err("validation", "Some fields need attention.", fieldErrors);
-                return ok(await entries.create(collection, fields));
+                return ok(await entries.create(collection, input.fields, { locale: input.locale, parentId: input.parentId ?? null }));
             }),
-            save: (collection, id, fields) => guard(async () => {
+            save: (collection, id, locale, fields) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
                 const fieldErrors = validateFields(fields, descriptors);
                 if (fieldErrors.length > 0)
                     return err("validation", "Some fields need attention.", fieldErrors);
-                const entry = await entries.update(collection, id, fields);
+                const entry = await entries.update(collection, id, locale, fields);
                 await fanOut(id);
                 return ok(entry);
             }),
-            setStatus: (collection, id, status) => guard(async () => {
-                const entry = await entries.setStatus(collection, id, status);
+            setStatus: (collection, id, locale, status) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const entry = await entries.setStatus(collection, id, locale, status);
                 await fanOut(id);
                 return ok(entry);
             }),
@@ -304,6 +419,73 @@ export function createAdminOps(deps) {
                 }
                 return ok(moved);
             }),
+            // A new locale starts as a draft: nothing public changes, nothing to expire.
+            addLocale: (collection, id, locale, options) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                return ok(await entries.addLocale(collection, id, locale, { from: options.from }));
+            }),
+            removeLocale: (collection, id, locale) => guard(async () => {
+                const unsupported = supportedLocale(locale);
+                if (unsupported)
+                    return unsupported;
+                const entry = await entries.removeLocale(collection, id, locale);
+                await fanOut(id);
+                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))),