smoodly 0.0.6 → 0.0.7

package/dist/admin/ops-impl.js

@@ -1,3 +1,4 @@
+import { entryFieldsIn } from "../entry-store.js";
 import { affectedTargets, entryTag, pageTag } from "../revalidate.js";
 import { ensureFixedNodes, fixedNodeOf } from "./fixed-nodes.js";
 import { validateFields } from "./validate.js";
@@ -30,6 +31,18 @@ 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("already exists"))
         return err("conflict", message);
     if (message.includes("is referenced by"))
@@ -100,15 +113,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 +142,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 +184,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 +226,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 +238,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 +255,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 +273,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 +292,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 +302,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 +388,21 @@ 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);
+            }),
         },
         preview: {
             enable: () => guard(async () => (await effects?.draft?.enable(), ok(null))),

package/dist/admin/ops.d.ts

@@ -14,7 +14,9 @@ export type OpResult<T> = {
 } | OpError;
 export type PageCreateInput = {
     parentId: string | null;
-    /** The default-locale segment. */
+    /** The one locale the page is created in; others are added with addLocale. */
+    locale: string;
+    /** The segment in that locale. */
     slug: string;
     /** Defaults to the slug. */
     title?: string;
@@ -22,24 +24,49 @@ export type PageCreateInput = {
     template: string | null;
 };
 export type PageGetResult = {
+    /** The node with ALL its locale rows — the switcher lists them. */
     record: PageRecord;
-    /** null for a folder. */
+    /** The locale this result was loaded for. */
+    locale: string;
+    /** That locale's draft tree; null for a folder, and null when the page has no row in `locale`. */
     draft: PageTree | null;
-    /** locale → locale-relative CMS path (the `paths` index). */
+    /** locale → locale-relative CMS path (the `paths` index), for the locales present. */
     paths: Record<string, string>;
     /** locale → site URL, `href` applied server-side (the canvas and "View live" use these). */
     urls: Record<string, string>;
+    /** The locales the PARENT exists in — a locale can only be added here
+     *  once the parent has it (DESIGN.md, Localization), so the editor
+     *  disables the rest with a reason. Every supported locale for a root
+     *  page: a root can be added to any locale. */
+    parentLocales: string[];
+};
+export type EntryCreateInput = {
+    /** The one locale the entry is created in; others are added with addLocale. */
+    locale: string;
+    parentId?: string | null;
+    /** The merged form: shared fields, that locale's localized fields and its slug. */
+    fields: Record<string, unknown>;
+};
+export type EntryGetResult = {
+    /** The node with ALL its locale rows — the switcher lists them. */
+    record: EntryRecord;
+    locale: string;
+    /** That locale's merged draft fields; null when the entry has no row in `locale`. */
+    fields: Record<string, unknown> | null;
+    /** The locales the PARENT exists in (every supported locale for a root) — the form disables the rest with a reason. */
+    parentLocales: string[];
 };
 export type AdminOps = {
     pages: {
-        /** Lists every node, materializing fixed pages and collection mounts first. */
+        /** Lists every node, materializing fixed pages and collection mounts (in every supported locale) first. */
         list(): Promise<OpResult<PageRecord[]>>;
-        get(id: string): Promise<OpResult<PageGetResult>>;
+        /** not_found only when the page is missing; an absent locale comes back with `draft: null`. */
+        get(id: string, locale: string): Promise<OpResult<PageGetResult>>;
         create(input: PageCreateInput): Promise<OpResult<PageRecord>>;
-        saveDraft(id: string, tree: PageTree): Promise<OpResult<{
+        saveDraft(id: string, locale: string, tree: PageTree): Promise<OpResult<{
             versionId: string;
         }>>;
-        publish(id: string): Promise<OpResult<PageRecord>>;
+        publish(id: string, locale: string): Promise<OpResult<PageRecord>>;
         delete(id: string): Promise<OpResult<null>>;
         rename(id: string, patch: {
             locale: string;
@@ -52,18 +79,31 @@ export type AdminOps = {
         }): Promise<OpResult<PageRecord>>;
         /** "Add page here": a folder becomes a page. */
         setTemplate(id: string, template: string): Promise<OpResult<PageRecord>>;
+        /** Copies `from`'s draft tree, title and slug as the new locale's first draft (spec 2026-09-06 §4). */
+        addLocale(id: string, locale: string, options: {
+            from: string;
+        }): Promise<OpResult<PageRecord>>;
+        /** Deletes the locale's row, versions and paths. Never on fixed nodes or the site root. */
+        removeLocale(id: string, locale: string): Promise<OpResult<PageRecord>>;
     };
     entries: {
         list(collection: string): Promise<OpResult<EntryRecord[]>>;
-        get(collection: string, id: string): Promise<OpResult<EntryRecord>>;
-        create(collection: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
-        save(collection: string, id: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
-        setStatus(collection: string, id: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
+        /** not_found only when the entry is missing; an absent locale comes back with `fields: null`. */
+        get(collection: string, id: string, locale: string): Promise<OpResult<EntryGetResult>>;
+        create(collection: string, input: EntryCreateInput): Promise<OpResult<EntryRecord>>;
+        save(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<OpResult<EntryRecord>>;
+        setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<OpResult<EntryRecord>>;
         delete(collection: string, id: string): Promise<OpResult<null>>;
         move(collection: string, id: string, to: {
             parentId: string | null;
             index?: number;
         }): Promise<OpResult<EntryRecord>>;
+        /** Copies `from`'s localized fields and slug as the new locale's draft (spec 2026-09-06 §7). Expires nothing. */
+        addLocale(collection: string, id: string, locale: string, options: {
+            from: string;
+        }): Promise<OpResult<EntryRecord>>;
+        /** Deletes the locale's row, versions and paths; fans out like a save. */
+        removeLocale(collection: string, id: string, locale: string): Promise<OpResult<EntryRecord>>;
     };
     preview: {
         enable(): Promise<OpResult<null>>;

package/dist/admin/shell/AdminApp.js

@@ -9,16 +9,15 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // column whose views own their own 48px top bar (the editor adds the third,
 // its 300px inspector). The shell is viewport-height; every column scrolls
 // inside itself.
-import { useEffect, useState } from "react";
+import { useState } from "react";
 import { makeClientOps } from "../client-ops.js";
-import { ListView } from "./ListView.js";
 import { PagesList } from "./PagesList.js";
+import { EntriesList } from "./EntriesList.js";
 import { EntryForm } from "./EntryForm.js";
 import { EditorView } from "../editor/EditorView.js";
 import { LoginView } from "./LoginView.js";
 import { useAdminSession } from "./session.js";
-import { Button, Logo, StatusBadge, ThemeToggle } from "../ui/primitives.js";
-import { relativeTime } from "../ui/format.js";
+import { Logo, ThemeToggle } from "../ui/primitives.js";
 import { BASE } from "./base.js";
 import { ErrorPane } from "./ErrorPane.js";
 /** Nav items the registry can't produce yet: shown, disabled, so the shape
@@ -30,34 +29,6 @@ function Nav({ registry, active, email, onSignOut }) {
     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" })] })] }));
 }
-function EntriesList({ ops, registry, collection }) {
-    const meta = registry.collections.find((c) => c.name === collection);
-    const [rows, setRows] = useState(null);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        ops.entries.list(collection)
-            .then((r) => (r.ok ? setRows(r.data) : setError(r.message)))
-            .catch(() => setError("Couldn't reach the server."));
-    }, [ops, collection]);
-    if (!meta)
-        return _jsx(ErrorPane, { message: "No such collection." });
-    if (error)
-        return _jsx(ErrorPane, { message: error });
-    const title = (e) => String((meta.titleField && e.fields[meta.titleField]) ?? Object.values(e.fields).find((v) => typeof v === "string") ?? e.id);
-    return (_jsx(ListView, { title: meta.title, count: rows?.length, actions: _jsx(Button, { onClick: () => { window.location.href = `${BASE}/${collection}/new`; }, children: "+ New entry" }), columns: [
-            { label: "Title", width: "minmax(160px,1fr)" },
-            { label: "Updated", width: "minmax(110px,160px)" },
-            { label: "Status", width: "120px" },
-        ], empty: rows ? "Nothing here yet." : "Loading…", rows: (rows ?? []).map((e) => ({
-            key: e.id,
-            href: `${BASE}/${collection}/${encodeURIComponent(e.id)}`,
-            cells: [
-                _jsx("span", { className: "sm-cell sm-cell--title", children: title(e) }, "t"),
-                _jsx("span", { className: "sm-cell sm-cell--muted", children: relativeTime(e.updatedAt) }, "u"),
-                _jsx(StatusBadge, { status: e.status }, "c"),
-            ],
-        })) }));
-}
 export function AdminApp({ registry, segments, op, auth }) {
     const session = useAdminSession(auth);
     const [ops] = useState(() => makeClientOps(op, session.token));

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

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

package/dist/admin/shell/EntriesList.js

@@ -0,0 +1,95 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// A collection's list for ONE selected locale: every record is a row;
+// a record absent from the selected locale is dimmed and its click is
+// "Add <locale>" (a confirm, then addLocale copying the source locale).
+// Opening a present row opens the form in the selected locale.
+import { useCallback, useEffect, useState } from "react";
+import { ListView } from "./ListView.js";
+import { entryRows, entrySourceLocale } from "./entries-list.js";
+import { Button, 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 selected locale survives a reload within the session; a stored
+ *  value that is no longer supported falls back to the default. */
+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 EntriesList({ ops, registry, collection }) {
+    const meta = registry.collections.find((c) => c.name === collection);
+    const [records, setRecords] = 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.entries.list(collection)
+            .then((r) => (r.ok ? setRecords(r.data) : setError(r.message)))
+            .catch(() => setError("Couldn't reach the server."));
+    }, [ops, collection]);
+    useEffect(load, [load]);
+    if (!meta)
+        return _jsx(ErrorPane, { message: "No such collection." });
+    if (error)
+        return _jsx(ErrorPane, { message: error });
+    const open = (id) => {
+        window.location.href = `${BASE}/${collection}/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`;
+    };
+    const addLocale = async (row) => {
+        const record = records?.find((r) => r.id === row.id);
+        if (!record)
+            return;
+        const from = entrySourceLocale(record, registry);
+        if (!window.confirm(`Add "${row.title}" to ${locale}? Its ${from} fields are copied as the first ${locale} draft.`))
+            return;
+        let result;
+        try {
+            result = await ops.entries.addLocale(collection, row.id, locale, { from });
+        }
+        catch {
+            result = { ok: false, code: "internal", message: "Couldn't reach the server." };
+        }
+        if (!result.ok) {
+            window.alert(result.message);
+            return;
+        }
+        open(row.id);
+    };
+    const rows = records ? entryRows(records, meta, registry, locale) : [];
+    return (_jsx(ListView, { title: meta.title, count: records?.length, actions: _jsxs(_Fragment, { children: [multilingual && _jsx(Segmented, { options: registry.locales.supported, value: locale, onChange: pickLocale }), _jsx(Button, { onClick: () => { window.location.href = `${BASE}/${collection}/new?locale=${encodeURIComponent(locale)}`; }, children: "+ New entry" })] }), columns: [
+            { label: "Title", width: "minmax(160px,1fr)" },
+            { label: "Updated", width: "minmax(110px,160px)" },
+            { label: "Status", width: "120px" },
+        ], empty: records ? "Nothing here yet." : "Loading…", rows: rows.map((row) => {
+            const dim = row.present ? undefined : { opacity: 0.45 };
+            return {
+                key: row.id,
+                onClick: () => (row.present ? open(row.id) : void addLocale(row)),
+                cells: [
+                    _jsx("span", { className: "sm-cell sm-cell--title", style: dim, children: row.title }, "t"),
+                    row.present
+                        ? _jsx("span", { className: "sm-cell sm-cell--muted", children: relativeTime(row.updatedAt) }, "u")
+                        : _jsxs("span", { className: "sm-cell sm-cell--muted", children: ["not in ", locale, " \u2014 click to add"] }, "u"),
+                    row.status
+                        ? _jsx(StatusBadge, { status: row.status }, "c")
+                        : _jsx("span", { className: "sm-cell sm-cell--muted", children: "\u2014" }, "c"),
+                ],
+            };
+        }) }));
+}