smoodly 0.0.23 → 0.0.25

package/dist/admin/forms/date-picker.js

@@ -0,0 +1,117 @@
+// Pure calendar and instant math for the date and datetime pickers (spec
+// 2026-09-25 date pickers §3). No DOM. Day arithmetic runs in UTC and
+// every zone conversion goes through Intl parts with an explicit zone —
+// never Date's local getters — so a test can pin any zone without
+// touching the process zone, and a browser's own zone never leaks in.
+const DAY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const INSTANT_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):00Z$/;
+const MS_PER_DAY = 86400000;
+const pad = (n) => String(n).padStart(2, "0");
+export function daysInMonth(y, m) {
+    return new Date(Date.UTC(y, m, 0)).getUTCDate();
+}
+/** Strict `YYYY-MM-DD`, and a day the calendar has (no 2026-02-30). */
+export function parseDay(s) {
+    const m = DAY_RE.exec(s);
+    if (!m)
+        return null;
+    const day = { y: Number(m[1]), m: Number(m[2]), d: Number(m[3]) };
+    if (day.m < 1 || day.m > 12 || day.d < 1 || day.d > daysInMonth(day.y, day.m))
+        return null;
+    return day;
+}
+export const formatDay = (day) => `${String(day.y).padStart(4, "0")}-${pad(day.m)}-${pad(day.d)}`;
+export const isSameDay = (a, b) => a.y === b.y && a.m === b.m && a.d === b.d;
+export const isCalendarDay = (s) => parseDay(s) !== null;
+const dayOf = (t) => {
+    const dt = new Date(t);
+    return { y: dt.getUTCFullYear(), m: dt.getUTCMonth() + 1, d: dt.getUTCDate() };
+};
+/** A day `n` days, weeks or months on (negative: back). A month step keeps the day, clamped to the target month's length. */
+export function stepDay(day, by, n) {
+    if (by === "month") {
+        const total = day.y * 12 + (day.m - 1) + n;
+        const y = Math.floor(total / 12);
+        const m = total - y * 12 + 1;
+        return { y, m, d: Math.min(day.d, daysInMonth(y, m)) };
+    }
+    return dayOf(Date.UTC(day.y, day.m - 1, day.d) + n * (by === "week" ? 7 : 1) * MS_PER_DAY);
+}
+/** Six rows of seven, Monday first, the month's days padded with the neighbours'. */
+export function monthGrid(y, m) {
+    const lead = (new Date(Date.UTC(y, m - 1, 1)).getUTCDay() + 6) % 7; // Monday = 0
+    let day = stepDay({ y, m, d: 1 }, "day", -lead);
+    const rows = [];
+    for (let r = 0; r < 6; r++) {
+        const row = [];
+        for (let c = 0; c < 7; c++) {
+            row.push(day);
+            day = stepDay(day, "day", 1);
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+/** "September 2026" in a language; English when none is given (static renders). */
+export function monthLabel(y, m, locale = "en") {
+    return new Intl.DateTimeFormat(locale, { month: "long", year: "numeric", timeZone: "UTC" }).format(new Date(Date.UTC(y, m - 1, 1)));
+}
+/** Short weekday names, Monday first (2024-01-01 was a Monday). */
+export function weekdayLabels(locale = "en") {
+    const f = new Intl.DateTimeFormat(locale, { weekday: "short", timeZone: "UTC" });
+    return [0, 1, 2, 3, 4, 5, 6].map((i) => f.format(new Date(Date.UTC(2024, 0, 1 + i))));
+}
+/** Strict ISO to the minute, seconds 00, Z. */
+export function parseInstant(s) {
+    const m = INSTANT_RE.exec(s);
+    if (!m)
+        return null;
+    const day = parseDay(m[1]);
+    if (!day)
+        return null;
+    const hour = Number(m[2]), minute = Number(m[3]);
+    if (hour > 23 || minute > 59)
+        return null;
+    return new Date(Date.UTC(day.y, day.m - 1, day.d, hour, minute));
+}
+export const formatInstant = (date) => `${formatDay(dayOf(date.getTime()))}T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:00Z`;
+export const isInstant = (s) => parseInstant(s) !== null;
+/** The clock of a zone at an instant, through Intl; `hourCycle: "h23"` so midnight is 0, never 24. */
+export function zoneParts(date, zone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: zone, hourCycle: "h23", year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit",
+    }).formatToParts(date);
+    const get = (type) => Number(parts.find((p) => p.type === type)?.value);
+    return { day: { y: get("year"), m: get("month"), d: get("day") }, hour: get("hour") % 24, minute: get("minute") };
+}
+export function toLocalParts(iso, zone) {
+    const date = parseInstant(iso);
+    return date ? zoneParts(date, zone) : null;
+}
+/** The instant at which the zone's clock reads the given wall time. A
+ *  fixed point: read the zone's clock at a guess, shift by the difference,
+ *  twice for a daylight-saving edge. A wall time that does not exist (the
+ *  spring-forward gap) lands on the instant an hour on. */
+export function fromLocalParts(day, hour, minute, zone) {
+    const want = Date.UTC(day.y, day.m - 1, day.d, hour, minute);
+    let guess = want;
+    for (let i = 0; i < 2; i++) {
+        const p = zoneParts(new Date(guess), zone);
+        const wall = Date.UTC(p.day.y, p.day.m - 1, p.day.d, p.hour, p.minute);
+        if (wall === want)
+            break;
+        guess += want - wall;
+    }
+    return formatInstant(new Date(guess));
+}
+export function todayIn(zone, now = new Date()) {
+    return zoneParts(now, zone).day;
+}
+export const HOURS = Array.from({ length: 24 }, (_, i) => i);
+/** The five-minute grid, plus a stored minute that is not on it. */
+export function minuteOptions(current) {
+    const grid = Array.from({ length: 12 }, (_, i) => i * 5);
+    if (current === null || grid.includes(current))
+        return grid;
+    return [...grid, current].sort((a, b) => a - b);
+}

package/dist/admin/forms/elements-context.d.ts

@@ -1,5 +1,8 @@
 import { type ReactElement, type ReactNode } from "react";
 import type { AdminElement } from "../serialize.ts";
+/** The list is handed on by content: the registry is re-serialized on every
+ *  server render (each autosave), and the richtext editor's deps must not
+ *  see a new array for the same elements (see useRichtextEditor, 2026-09-26). */
 export declare function ElementsProvider({ elements, children }: {
     elements: AdminElement[];
     children: ReactNode;

package/dist/admin/forms/elements-context.js

@@ -3,10 +3,15 @@ import { jsx as _jsx } from "react/jsx-runtime";
 // The serialized element descriptors, for the richtext widget's insert
 // menu and element cards. Defaults to none, so a form rendered without
 // the shell (tests, a bare page) still works.
-import { createContext, useContext } from "react";
+import { createContext, useContext, useMemo } from "react";
 const Ctx = createContext([]);
+/** The list is handed on by content: the registry is re-serialized on every
+ *  server render (each autosave), and the richtext editor's deps must not
+ *  see a new array for the same elements (see useRichtextEditor, 2026-09-26). */
 export function ElementsProvider({ elements, children }) {
-    return _jsx(Ctx.Provider, { value: elements, children: children });
+    const key = JSON.stringify(elements);
+    const stable = useMemo(() => elements, [key]); // eslint-disable-line react-hooks/exhaustive-deps
+    return _jsx(Ctx.Provider, { value: stable, children: children });
 }
 export function useElements() {
     return useContext(Ctx);

package/dist/admin/forms/time-zone-context.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement, type ReactNode } from "react";
+export declare function TimeZoneProvider({ zone, children }: {
+    zone?: string;
+    children: ReactNode;
+}): ReactElement;
+/** The configured zone, or undefined. */
+export declare function useTimeZone(): string | undefined;

package/dist/admin/forms/time-zone-context.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// The site's time zone from the registry (spec 2026-09-25 date pickers
+// §5), for the datetime widget. Undefined = none configured: the widget
+// falls back to the browser's zone and says so. Defaults to undefined so
+// a form rendered without the shell (tests, a bare page) still works.
+import { createContext, useContext } from "react";
+const Ctx = createContext(undefined);
+export function TimeZoneProvider({ zone, children }) {
+    return _jsx(Ctx.Provider, { value: zone, children: children });
+}
+/** The configured zone, or undefined. */
+export function useTimeZone() {
+    return useContext(Ctx);
+}

package/dist/admin/forms/useRichtextEditor.js

@@ -28,7 +28,16 @@ const EMPTY = { type: "doc", content: [{ type: "paragraph" }] };
 const LEVELS = [1, 2, 3, 4, 5, 6];
 const isDoc = (v) => !!v && typeof v === "object" && v.type === "doc";
 export function useRichtextEditor({ value, toolset, onChange, contentClass, onEscape }) {
-    const allowed = useMemo(() => allowedOf(toolset), [toolset]);
+    // Keyed by content, not identity: the registry crosses the server → client
+    // boundary and is re-serialized whenever the route's server tree renders
+    // again — every autosave does that, since the op is a Server Action that
+    // expires the page's cache tag — so `toolset` arrives as a new object with
+    // the same content. On identity TipTap rebuilt the editor after each save,
+    // dropping its undo history and the focus (found 2026-09-26: cmd-Z did
+    // nothing once the first autosave had landed). The elements list is made
+    // stable the same way in ElementsProvider.
+    const toolsetKey = JSON.stringify(toolset ?? null);
+    const allowed = useMemo(() => allowedOf(toolset), [toolsetKey]); // eslint-disable-line react-hooks/exhaustive-deps
     const elements = useElements();
     const assets = useAssets();
     const items = useMemo(() => insertItems(allowed, elements), [allowed, elements]);

package/dist/admin/index.d.ts

@@ -1,4 +1,6 @@
 export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, GlobalListItem, GlobalGetResult, AssetUsageItem, MembersListResult } from "./ops.ts";
+export type { InviteInput, InviteResult, MemberRecord } from "../member-store.ts";
+export type { MemberRole } from "../permissions.ts";
 export { createAdminOps, runAdminOp, type AdminEffects } from "./ops-impl.ts";
 export { fixedNodeSpecs, fixedNodeOf, ensureFixedNodes, type FixedNode } from "./fixed-nodes.ts";
 export { ensureGlobalItems, initialGlobalFields } from "./global-items.ts";

package/dist/admin/next/bridge.d.ts

@@ -1 +1,2 @@
-export declare function EditorBridge(): null;
+import { type ReactElement } from "react";
+export declare function EditorBridge(): ReactElement;

package/dist/admin/next/bridge.js

@@ -1,16 +1,32 @@
 "use client";
+import { jsx as _jsx } from "react/jsx-runtime";
 // Runs INSIDE the draft-route iframe (glue adds it only when draft mode +
 // the editor param are on). Reports geometry — section nodes, empty zones
 // and, since spec 2026-09-10, every marked field with its resolved path —
 // forwards select/hover with the field under the pointer, executes
 // refresh/scroll, and says when a render has committed. The admin overlay
-// draws all chrome. Rects are in document coordinates: the iframe is sized
+// draws all chrome — bar one rule this component renders: a section that
+// renders nothing (a fresh custom section, an all-optional section left
+// empty) is stamped blank and takes a min-height, so the editor can see
+// and select it; the live site never mounts the bridge, so it keeps its
+// true height. Rects are in document coordinates: the iframe is sized
 // to the full document height by the editor, so client rects + scroll
 // offsets map 1:1 onto the overlay.
 import { useEffect } from "react";
 import { useRouter } from "next/navigation";
-import { EDITOR_ATTR, FIELD_ATTR, NODE_ATTR, ZONE_ATTR, resolveMarkPath } from "../../marks.js";
+import { BLANK_ATTR, EDITOR_ATTR, FIELD_ATTR, NODE_ATTR, ZONE_ATTR, resolveMarkPath } from "../../marks.js";
 const post = (m) => window.parent.postMessage(m, "*");
+/** The height of an md-spaced section with nothing inside (3.5rem + 3.5rem). */
+// The editor sizes the iframe to the reported height; the document's own
+// viewport must never scroll (2026-09-26): a fractional content height
+// (4595.3px in a 4595px frame) left it scrollable by a hair, and a
+// trackpad scroll over the canvas showed the frame's overlay scrollbar.
+// Hidden overflow drops no layout — programmatic scrollIntoView still
+// works, and the live site never mounts this.
+const BRIDGE_CSS = `html{overflow:hidden}[${NODE_ATTR}][${BLANK_ATTR}]{min-height:7rem}`;
+const MEDIA = "img,picture,video,audio,svg,canvas,iframe,object";
+/** No visible text (innerText skips <style> and hidden content) and no media. */
+const isBlank = (el) => el.innerText.trim() === "" && el.querySelector(MEDIA) === null;
 export function EditorBridge() {
     const router = useRouter();
     // Every commit of this component — the mount, then each RSC refresh,
@@ -28,7 +44,19 @@ export function EditorBridge() {
         const report = () => {
             // Array.from, not spread: the package's lib set is ES2020 + DOM
             // (no DOM.Iterable), so a NodeList isn't statically iterable here.
-            const nodes = all(`[${NODE_ATTR}]`).map((el) => ({ id: el.getAttribute(NODE_ATTR), ...docRect(el) }));
+            const roots = all(`[${NODE_ATTR}]`);
+            // Stamp before measuring, so the min-height is in the rects; only on a
+            // change, so the attribute mutation this causes converges instead of looping.
+            for (const el of roots) {
+                const blank = isBlank(el);
+                if (blank !== el.hasAttribute(BLANK_ATTR)) {
+                    if (blank)
+                        el.setAttribute(BLANK_ATTR, "");
+                    else
+                        el.removeAttribute(BLANK_ATTR);
+                }
+            }
+            const nodes = roots.map((el) => ({ id: el.getAttribute(NODE_ATTR), ...docRect(el) }));
             const emptyZones = all(`[${ZONE_ATTR}]`).map((el) => ({ zone: el.getAttribute(ZONE_ATTR), ...docRect(el) }));
             const fields = [];
             for (const el of all(`[${FIELD_ATTR}]`)) {
@@ -39,7 +67,9 @@ export function EditorBridge() {
                 if (mark)
                     fields.push({ ...mark, ...docRect(el) });
             }
-            post({ source: "smoodly", kind: "rects", nodes, emptyZones, fields, docH: document.documentElement.scrollHeight });
+            // Rounded up from the fractional box, so the frame is never a hair too short.
+            const docH = Math.ceil(Math.max(document.documentElement.scrollHeight, document.documentElement.getBoundingClientRect().height));
+            post({ source: "smoodly", kind: "rects", nodes, emptyZones, fields, docH });
         };
         const raf = () => requestAnimationFrame(report);
         const ro = new ResizeObserver(raf);
@@ -93,5 +123,5 @@ export function EditorBridge() {
             window.removeEventListener("message", onMessage);
         };
     }, [router]);
-    return null;
+    return _jsx("style", { "data-smoodly-bridge": "", children: BRIDGE_CSS });
 }

package/dist/admin/next/index.d.ts

@@ -1,6 +1,8 @@
 export { createAdminOpHandler } from "./op-handler.ts";
 export { createSmoodlyAdmin } from "./create-admin.tsx";
 export type { AdminOpCall, AdminOpAction, AdminOps, OpResult, MembersListResult } from "../ops.ts";
+export type { InviteInput, InviteResult, MemberRecord } from "../../member-store.ts";
+export type { MemberRole } from "../../permissions.ts";
 export type { AuthConfig } from "../shell/session.ts";
 export type { AdminAuth } from "../auth.ts";
 export { supabaseAdminAuth } from "../supabase-auth.ts";

package/dist/admin/ops-impl.js

@@ -1,5 +1,6 @@
 import { entryFieldsIn, entryTitleIn } from "../entry-store.js";
 import { distinctTags } from "../tags.js";
+import { can, isMemberRole, normalizeRole } from "../permissions.js";
 import { ASSET_COLLECTION } from "../media.js";
 import { adminHref, adminSlugTaken, isAdminSlug } from "../admin-path.js";
 import { affectedTargets, collectionTag, entryTag, pageTag, pagesTreeTag, globalTag } from "../revalidate.js";
@@ -10,6 +11,7 @@ import { CUSTOM_NODE_TYPE, customSchema } from "../custom/index.js";
 import { SETTINGS_KEY, CSS_KEY } from "../global.js";
 import { withDefaults } from "../field-defaults.js";
 import { elementSchemas } from "../richtext-walk.js";
+import { SCHEMA_VERSION } from "../schema-version.js";
 const ok = (data) => ({ ok: true, data });
 /** A history row without its content (spec 2026-09-13 history §6). */
 const summary = ({ id, savedAt }) => ({ id, savedAt });
@@ -87,7 +89,7 @@ const classify = (e) => {
         return err("validation", message);
     if (message.includes("not a valid slug"))
         return err("validation", message);
-    if (message.includes("no page") || message.includes("no entry") || message.includes("no collection") || message.includes("no asset"))
+    if (message.includes("no page") || message.includes("no entry") || message.includes("no collection") || message.includes("no asset") || message.includes("no member"))
         return err("not_found", message);
     if (message.includes("not pending"))
         return err("conflict", message);
@@ -201,6 +203,26 @@ export function createAdminOps(deps) {
     const assets = deps.assets;
     const noMedia = () => err("internal", "smoodly: no media store is configured — pass `assets` to createAdminOpHandler.");
     const noMembers = () => err("internal", "smoodly: no member store is configured — pass `members` to createAdminOpHandler.");
+    const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    /** unauthorized unless the actor may manage members; no actor (scripts, the seed) may. */
+    const membersDenied = () => deps.actor && !can(deps.actor.role, "members.manage") ? err("unauthorized", "smoodly: only an admin can manage members.") : null;
+    /** blocked when the control plane manages this space's members (a row, never a mode check). */
+    const membersManaged = async () => (await deps.members.consoleUrl()) ? err("blocked", "smoodly: members are managed at smoodly.io.") : null;
+    /** The two guards on setRole and remove: never your own row, never the last admin (unless the change keeps them admin). */
+    const memberGuards = async (userId, staysAdmin) => {
+        if (deps.actor?.userId === userId)
+            return err("blocked", "smoodly: you cannot change your own membership.");
+        if (staysAdmin)
+            return null;
+        const rows = await deps.members.list();
+        const target = rows.find((m) => m.userId === userId);
+        if (!target)
+            return null; // the store answers not_found
+        const admins = rows.filter((m) => normalizeRole(m.role) === "admin");
+        if (normalizeRole(target.role) === "admin" && admins.length <= 1)
+            return err("blocked", "smoodly: this site needs at least one admin.");
+        return null;
+    };
     const mb = (bytes) => `${Math.round((bytes / (1024 * 1024)) * 10) / 10} MB`;
     const isDim = (v) => v === undefined || (typeof v === "number" && Number.isFinite(v) && v >= 0);
     /** What an asset's usage row points at, labelled for the Media screen. */
@@ -854,9 +876,59 @@ export function createAdminOps(deps) {
             list: () => guard(async () => {
                 if (!deps.members)
                     return noMembers();
+                const denied = membersDenied();
+                if (denied)
+                    return denied;
                 const [members, consoleUrl] = await Promise.all([deps.members.list(), deps.members.consoleUrl()]);
                 return ok({ members, consoleUrl });
             }),
+            me: () => guard(async () => ok({ role: deps.actor?.role ?? "admin" })),
+            invite: (input) => guard(async () => {
+                if (!deps.members)
+                    return noMembers();
+                const refused = membersDenied() ?? (await membersManaged());
+                if (refused)
+                    return refused;
+                const email = typeof input?.email === "string" ? input.email.trim() : "";
+                if (!EMAIL_RE.test(email))
+                    return err("validation", "smoodly: enter a valid email address.");
+                if (!isMemberRole(input.role))
+                    return err("validation", "smoodly: the role must be admin or editor.");
+                if (typeof input.redirectTo !== "string" || !input.redirectTo)
+                    return err("validation", "smoodly: the invite needs a return URL.");
+                const rows = await deps.members.list();
+                if (rows.some((m) => m.email?.toLowerCase() === email.toLowerCase()))
+                    return err("conflict", "smoodly: already a member.");
+                return ok(await deps.members.invite({ email, role: input.role, redirectTo: input.redirectTo }));
+            }),
+            setRole: (userId, role) => guard(async () => {
+                if (!deps.members)
+                    return noMembers();
+                const refused = membersDenied() ?? (await membersManaged());
+                if (refused)
+                    return refused;
+                if (!isMemberRole(role))
+                    return err("validation", "smoodly: the role must be admin or editor.");
+                const guardHit = await memberGuards(userId, role === "admin");
+                if (guardHit)
+                    return guardHit;
+                return ok(await deps.members.setRole(userId, role));
+            }),
+            remove: (userId) => guard(async () => {
+                if (!deps.members)
+                    return noMembers();
+                const refused = membersDenied() ?? (await membersManaged());
+                if (refused)
+                    return refused;
+                const guardHit = await memberGuards(userId, false);
+                if (guardHit)
+                    return guardHit;
+                await deps.members.remove(userId);
+                return ok(null);
+            }),
+        },
+        schema: {
+            status: () => guard(async () => ok({ database: await pages.schemaVersion(), required: SCHEMA_VERSION })),
         },
         preview: {
             enable: () => guard(async () => (await effects?.draft?.enable(), ok(null))),

package/dist/admin/ops.d.ts

@@ -3,7 +3,8 @@ import type { PageTree } from "../render.tsx";
 import type { EntryRecord, EntryUsage } from "../entry-store.ts";
 import type { AssetRecord, AssetMeta } from "../media.ts";
 import type { AssetPage, AssetQuery, FinishInput, UploadTicket } from "../asset-store.ts";
-import type { MemberRecord } from "../member-store.ts";
+import type { InviteInput, InviteResult, MemberRecord } from "../member-store.ts";
+import type { MemberRole } from "../permissions.ts";
 import type { FieldError } from "./validate.ts";
 export type OpError = {
     ok: false;
@@ -97,6 +98,11 @@ export type MembersListResult = {
     members: MemberRecord[];
     consoleUrl: string | null;
 };
+/** `database` null = no smoodly_meta table (older than v1). Behind blocks the shell; ahead is silent (spec 2026-09-26 §5). */
+export type SchemaStatus = {
+    database: number | null;
+    required: number;
+};
 export type AdminOps = {
     pages: {
         /** Lists every node, materializing fixed pages and collection mounts (in every supported locale) first. */
@@ -196,8 +202,22 @@ export type AdminOps = {
         usage(id: string): Promise<OpResult<AssetUsageItem[]>>;
     };
     members: {
-        /** The space's members, read-only in this cut; `consoleUrl` set means smoodly.io manages them. */
+        /** The space's members; admins only. `consoleUrl` set means smoodly.io manages them and every write below is blocked. */
         list(): Promise<OpResult<MembersListResult>>;
+        /** The caller's role; every member. The shell hides Settings from editors with it. */
+        me(): Promise<OpResult<{
+            role: MemberRole;
+        }>>;
+        /** Admins only, self-host only: invites (or adds an existing account), refuses a duplicate row (spec 2026-09-25 members management §3). */
+        invite(input: InviteInput): Promise<OpResult<InviteResult>>;
+        /** Admins only, self-host only; never your own row, never the last admin. */
+        setRole(userId: string, role: MemberRole): Promise<OpResult<MemberRecord>>;
+        /** Admins only, self-host only; the same two guards. The Auth account stays. */
+        remove(userId: string): Promise<OpResult<null>>;
+    };
+    schema: {
+        /** Every member. The shell calls it once on mount and blocks when behind. */
+        status(): Promise<OpResult<SchemaStatus>>;
     };
     preview: {
         enable(): Promise<OpResult<null>>;

package/dist/admin/serialize.d.ts

@@ -74,6 +74,8 @@ export type AdminRegistry = {
         default: string;
         supported: string[];
     };
+    /** The site's time zone when configured (spec 2026-09-25 date pickers §5); the datetime widget edits in it. */
+    timeZone?: string;
     /** The project's custom-CSS flag (spec 2026-09-14 §4). */
     css: boolean;
     /** Which slug the site root serves. */

package/dist/admin/serialize.js

@@ -104,6 +104,7 @@ export function serializeAdminConfig(config) {
         },
         css: config.css,
         locales: config.locales,
+        ...(config.timeZone !== undefined ? { timeZone: config.timeZone } : {}),
         homePageSlug: config.homePageSlug,
         pageDepth: config.pageDepth,
         media: { maxSize: config.media.maxSize, accept: [...config.media.accept] },

package/dist/admin/shell/AdminApp.js

@@ -12,7 +12,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // (shell/IconRail.tsx), then the main column whose views own their own
 // 48px top bar (the editor adds the third, its inspector). The shell is
 // viewport-height; every column scrolls inside itself.
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { makeClientOps } from "../client-ops.js";
 import { PagesList } from "./PagesList.js";
 import { EntriesList } from "./EntriesList.js";
@@ -21,16 +21,22 @@ import { GlobalList } from "./GlobalList.js";
 import { GlobalForm } from "./GlobalForm.js";
 import { EditorView } from "../editor/EditorView.js";
 import { LoginView } from "./LoginView.js";
+import { SetPasswordView } from "./SetPasswordView.js";
 import { useAdminSession } from "./session.js";
 import { IconRail } from "./IconRail.js";
+import { ConfirmHost } from "../ui/ConfirmDialog.js";
 import { useRoute } from "./router.js";
 import { AdminPathProvider } from "./base.js";
 import { mountMismatch } from "../../admin-path.js";
+import { can } from "../../permissions.js";
 import { ErrorPane } from "./ErrorPane.js";
 import { MediaScreen } from "./MediaScreen.js";
 import { SettingsView } from "./SettingsView.js";
 import { AssetsProvider } from "../forms/assets-context.js";
 import { ElementsProvider } from "../forms/elements-context.js";
+import { TimeZoneProvider } from "../forms/time-zone-context.js";
+import { SchemaNotice } from "./SchemaNotice.js";
+import { schemaBehind } from "../../schema-version.js";
 export function AdminApp({ registry, op, auth }) {
     const session = useAdminSession(auth);
     const [ops] = useState(() => makeClientOps(op, session.token));
@@ -38,6 +44,40 @@ export function AdminApp({ registry, op, auth }) {
     const [head = "pages", tail] = route.segments.length ? route.segments : ["pages"];
     const isCollection = registry.collections.some((c) => c.name === head);
     const email = session.state.status === "signed_in" ? session.state.session.user.email : undefined;
+    // The role rides on members.me (members management §2): Settings hides
+    // from an editor, and the area itself refuses. Unknown until it answers.
+    const signedIn = session.state.status === "signed_in";
+    const [role, setRole] = useState(null);
+    useEffect(() => {
+        if (!signedIn) {
+            setRole(null);
+            return;
+        }
+        let live = true;
+        ops.members.me()
+            .then((r) => { if (live)
+            setRole(r.ok ? r.data.role : "editor"); })
+            .catch(() => { if (live)
+            setRole("editor"); });
+        return () => { live = false; };
+    }, [signedIn, ops]);
+    // The one version check (spec 2026-09-26 §5): behind blocks the shell,
+    // equal or ahead renders as usual. Unknown until it answers; a failed
+    // call renders as usual too — the notice is for a known-behind schema.
+    const [schema, setSchema] = useState(null);
+    useEffect(() => {
+        if (!signedIn) {
+            setSchema(null);
+            return;
+        }
+        let live = true;
+        ops.schema.status()
+            .then((r) => { if (live && r.ok)
+            setSchema(r.data); })
+            .catch(() => { });
+        return () => { live = false; };
+    }, [signedIn, ops]);
+    const userId = session.state.status === "signed_in" ? session.state.session.user.id : "";
     if (session.state.status === "loading") {
         return (_jsx("div", { style: { height: "100vh", display: "grid", placeItems: "center", color: "var(--text-muted)" }, children: "Loading\u2026" }));
     }
@@ -47,6 +87,11 @@ export function AdminApp({ registry, op, auth }) {
     }
     if (session.state.status === "signed_out")
         return _jsx(LoginView, { client: session.client, providers: auth.providers });
+    // An invite or reset link signed the person in: Set password before the shell (members management §6).
+    if (session.arrival)
+        return _jsx(SetPasswordView, { client: session.client, mode: session.arrival, onDone: session.clearArrival });
+    if (schema && schemaBehind(schema.database, schema.required))
+        return _jsx(SchemaNotice, { status: schema });
     let main;
     if (head === "pages" && !tail)
         main = _jsx(PagesList, { ops: ops, registry: registry });
@@ -61,10 +106,10 @@ export function AdminApp({ registry, op, auth }) {
     else if (head === "globals" && tail)
         main = _jsx(GlobalForm, { ops: ops, registry: registry, name: decodeURIComponent(tail) });
     else if (head === "settings")
-        main = _jsx(SettingsView, { ops: ops, tail: tail });
+        main = _jsx(SettingsView, { ops: ops, tail: tail, role: role, userId: userId });
     else if (head === "media")
         main = _jsx(MediaScreen, {});
     else
         main = _jsx(ErrorPane, { message: "Not found." });
-    return (_jsx(AdminPathProvider, { value: registry.adminPath, children: _jsx(ElementsProvider, { elements: registry.elements, children: _jsx(AssetsProvider, { ops: ops, media: registry.media, children: _jsxs("div", { className: "sm-shell", children: [_jsx(IconRail, { registry: registry, active: head, email: email, onSignOut: () => session.client.auth.signOut() }), _jsx("main", { className: "sm-main", children: main }, `${head}/${tail ?? ""}`)] }) }) }) }));
+    return (_jsx(AdminPathProvider, { value: registry.adminPath, children: _jsx(ElementsProvider, { elements: registry.elements, children: _jsx(TimeZoneProvider, { zone: registry.timeZone, children: _jsxs(AssetsProvider, { ops: ops, media: registry.media, children: [_jsxs("div", { className: "sm-shell", children: [_jsx(IconRail, { registry: registry, active: head, email: email, settings: role !== null && can(role, "settings"), onSignOut: () => session.client.auth.signOut() }), _jsx("main", { className: "sm-main", children: main }, `${head}/${tail ?? ""}`)] }), _jsx(ConfirmHost, {})] }) }) }) }));
 }

package/dist/admin/shell/EntriesList.js

@@ -14,34 +14,19 @@ import { relativeTime } from "../ui/format.js";
 import { useSortable } from "../ui/useSortable.js";
 import { useAdminHref } from "./base.js";
 import { navigate } from "./router.js";
+import { confirm } from "../ui/confirm.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;
-}
+import { rememberLocale, rememberedLocale } from "./locale-memory.js";
 export function EntriesList({ ops, registry, collection }) {
     const adminHref = useAdminHref();
     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 [locale, setLocale] = useState(() => rememberedLocale(registry.locales));
     const multilingual = registry.locales.supported.length > 1;
     const pickLocale = (next) => {
         setLocale(next);
-        try {
-            window.sessionStorage.setItem(LOCALE_KEY, next);
-        }
-        catch { /* see rememberedLocale */ }
+        rememberLocale(next);
     };
     const load = useCallback(() => ops.entries.list(collection)
         .then((r) => (r.ok ? setRecords(r.data) : setError(r.message)))
@@ -75,7 +60,7 @@ export function EntriesList({ ops, registry, collection }) {
     if (error)
         return _jsx(ErrorPane, { message: error });
     const open = (id) => {
-        navigate(adminHref(`/${collection}/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`));
+        void navigate(adminHref(`/${collection}/${encodeURIComponent(id)}?locale=${encodeURIComponent(locale)}`));
     };
     /** "+ New entry" creates an empty draft in the locale on screen and opens it (spec 2026-09-14 §4). */
     const createEntry = async () => {
@@ -97,7 +82,13 @@ export function EntriesList({ ops, registry, collection }) {
         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.`))
+        const ok = await confirm({
+            title: `Add this entry to ${locale}?`,
+            body: `Its ${from} fields are copied as the first ${locale} draft. Nothing is published until you publish it.`,
+            confirmLabel: `Add to ${locale}`,
+            subject: { name: row.title },
+        });
+        if (!ok)
             return;
         let result;
         try {