smoodly 0.0.9 → 0.0.11

package/dist/admin/forms/RichtextWidget.js

@@ -0,0 +1,123 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The richtext field widget (spec 2026-09-08 §3): a TipTap editor under a
+// fixed toolbar. The editor owns its document and emits TipTap JSON on
+// every change; the parent stores the emitted document by reference, so
+// a value that is not the last emitted document is a change from outside
+// (load, locale switch, a list row moving) and re-seeds the editor. The
+// schema is always full; `allowed` gates creation (extensions, paste,
+// toolbar). Only this file and richtext-extensions.ts import TipTap.
+import { useEffect, useMemo, useRef, useState } from "react";
+import { EditorContent, useEditor, useEditorState } from "@tiptap/react";
+import { Slice } from "@tiptap/pm/model";
+import { allowedOf } from "../../toolset.js";
+import { plainDoc } from "../richtext-doc.js";
+import { Button } from "../ui/primitives.js";
+import { richtextExtensions } from "./richtext-extensions.js";
+import { gatePastedSlice } from "./richtext-paste.js";
+import { INACTIVE, RichtextToolbar } from "./RichtextToolbar.js";
+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 RichtextWidget({ value, toolset, onChange }) {
+    const allowed = useMemo(() => allowedOf(toolset), [toolset]);
+    // The parent's onChange closes over its render; the editor's onUpdate is
+    // created once, so read the latest through a ref.
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    // The last document this widget emitted — anything else arriving as
+    // `value` came from outside and re-seeds the editor.
+    const emitted = useRef(value);
+    const [link, setLink] = useState({ open: false, href: "" });
+    const openLinkRef = useRef(() => { });
+    const editor = useEditor({
+        immediatelyRender: false,
+        extensions: richtextExtensions(allowed, { onLink: () => openLinkRef.current() }),
+        content: isDoc(value) ? value : EMPTY,
+        editorProps: {
+            attributes: { class: "sm-richtext__content" },
+            transformPasted: (slice, view) => Slice.fromJSON(view.state.schema, gatePastedSlice(slice.toJSON(), allowed)),
+        },
+        onUpdate: ({ editor }) => {
+            const doc = plainDoc(editor.getJSON());
+            emitted.current = doc;
+            onChangeRef.current(doc);
+        },
+    }, [allowed]);
+    useEffect(() => {
+        if (!editor || value === emitted.current)
+            return;
+        emitted.current = value;
+        editor.commands.setContent(isDoc(value) ? value : EMPTY, { emitUpdate: false });
+    }, [editor, value]);
+    const active = useEditorState({
+        editor,
+        selector: ({ editor }) => editor
+            ? {
+                bold: editor.isActive("bold"),
+                italic: editor.isActive("italic"),
+                link: editor.isActive("link"),
+                bulletList: editor.isActive("bulletList"),
+                orderedList: editor.isActive("orderedList"),
+                blockquote: editor.isActive("blockquote"),
+                heading: LEVELS.find((level) => editor.isActive("heading", { level })) ?? null,
+            }
+            : INACTIVE,
+    });
+    // Read the caret's link from the editor at open time, not from the last
+    // render: a selection change and the press can land in the same tick.
+    const openLink = () => setLink({ open: true, href: editor?.getAttributes("link").href ?? "" });
+    openLinkRef.current = openLink;
+    const closeLink = () => {
+        setLink({ open: false, href: "" });
+        editor?.commands.focus();
+    };
+    const applyLink = () => {
+        if (!editor)
+            return;
+        const href = link.href.trim();
+        const chain = editor.chain().focus().extendMarkRange("link");
+        if (href === "")
+            chain.unsetLink().run();
+        else
+            chain.setLink({ href }).run();
+        setLink({ open: false, href: "" });
+    };
+    const removeLink = () => {
+        editor?.chain().focus().extendMarkRange("link").unsetLink().run();
+        setLink({ open: false, href: "" });
+    };
+    const run = (command) => {
+        if (!editor)
+            return;
+        if (command === "link") {
+            openLink();
+            return;
+        }
+        const chain = editor.chain().focus();
+        if (typeof command === "object")
+            chain.toggleHeading({ level: command.heading }).run();
+        else if (command === "bold")
+            chain.toggleBold().run();
+        else if (command === "italic")
+            chain.toggleItalic().run();
+        else if (command === "bulletList")
+            chain.toggleBulletList().run();
+        else if (command === "orderedList")
+            chain.toggleOrderedList().run();
+        else if (command === "blockquote")
+            chain.toggleBlockquote().run();
+    };
+    return (_jsxs("div", { className: "sm-richtext", children: [_jsx(RichtextToolbar, { allowed: allowed, active: active ?? INACTIVE, onCommand: run }), link.open && (_jsxs("div", { className: "sm-richtext__link", children: [_jsx("input", { className: "sm-input", placeholder: "https://\u2026 or /path", value: link.href, autoFocus: true, "aria-label": "Link URL", onChange: (e) => setLink({ open: true, href: e.target.value }), onKeyDown: (e) => {
+                            // Escape must not reach the editor's window handler, which clears the block selection.
+                            if (e.key === "Enter") {
+                                e.preventDefault();
+                                applyLink();
+                            }
+                            if (e.key === "Escape") {
+                                e.preventDefault();
+                                e.stopPropagation();
+                                closeLink();
+                            }
+                        } }), _jsx(Button, { onClick: applyLink, children: "Apply" }), _jsx(Button, { variant: "secondary", onClick: removeLink, children: "Remove" })] })), _jsx(EditorContent, { editor: editor })] }));
+}

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

@@ -0,0 +1,19 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { AdminOps } from "../ops.ts";
+import type { AdminRegistry } from "../serialize.ts";
+import type { AssetRecord } from "../../media.ts";
+import { type UploadDeps } from "./upload.ts";
+export type AssetsApi = {
+    ops: AdminOps["assets"];
+    get(id: string): Promise<AssetRecord | null>;
+    remember(record: AssetRecord): void;
+    upload: UploadDeps;
+    media: AdminRegistry["media"];
+};
+export declare function AssetsProvider({ ops, media, upload, children }: {
+    ops: AdminOps;
+    media: AdminRegistry["media"];
+    upload?: UploadDeps;
+    children: ReactNode;
+}): ReactElement;
+export declare function useAssets(): AssetsApi;

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

@@ -0,0 +1,35 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// The one place widgets reach the assets ops: a context with a small
+// record cache (an id fetched once per shell lifetime), the field
+// limits from the registry, and the injectable upload deps.
+import { createContext, useContext, useMemo, useRef } from "react";
+import { putSigned } from "./upload.js";
+import { measureFile } from "./measure.js";
+const Ctx = createContext(null);
+export function AssetsProvider({ ops, media, upload, children }) {
+    const cache = useRef(new Map());
+    const api = useMemo(() => ({
+        ops: ops.assets,
+        media,
+        upload: upload ?? { put: putSigned, measure: measureFile },
+        remember: (record) => { cache.current.set(record.id, record); },
+        get: async (id) => {
+            const hit = cache.current.get(id);
+            if (hit)
+                return hit;
+            const r = await ops.assets.get(id);
+            if (!r.ok)
+                return null;
+            cache.current.set(id, r.data);
+            return r.data;
+        },
+    }), [ops, media, upload]);
+    return _jsx(Ctx.Provider, { value: api, children: children });
+}
+export function useAssets() {
+    const api = useContext(Ctx);
+    if (!api)
+        throw new Error("smoodly: useAssets() needs an <AssetsProvider> above it.");
+    return api;
+}

package/dist/admin/forms/crop-editor.d.ts

@@ -0,0 +1,13 @@
+import { type Crop, type Hotspot, type ImageValue } from "../../media.ts";
+export type Handle = "nw" | "ne" | "sw" | "se";
+export type CropState = {
+    crop: Crop;
+    hotspot: Hotspot;
+};
+export declare const MIN_SIDE = 0.05;
+export declare function fitAspect(aspect: number, imageAspect: number): Crop;
+export declare function moveCrop(crop: Crop, dx: number, dy: number): Crop;
+export declare function resizeCrop(crop: Crop, handle: Handle, dx: number, dy: number, lock?: number, min?: number): Crop;
+export declare function placeHotspot(h: Hotspot, crop: Crop): Hotspot;
+export declare function relock(state: CropState, aspect: number | undefined, imageAspect: number): CropState;
+export declare function initialState(value: ImageValue | undefined, aspect: number | undefined, imageAspect: number): CropState;

package/dist/admin/forms/crop-editor.js

@@ -0,0 +1,72 @@
+// The crop editor's math, pure (spec 2026-09-08 media §10): everything in
+// fractions of the original image. A "lock" is the wanted pixel ratio
+// divided by the image's own, i.e. the ratio crop.width / crop.height
+// must keep.
+import { CENTER_HOTSPOT, FULL_CROP, clamp01 } from "../../media.js";
+export const MIN_SIDE = 0.05;
+export function fitAspect(aspect, imageAspect) {
+    const fa = aspect / imageAspect;
+    const width = fa <= 1 ? fa : 1;
+    const height = fa <= 1 ? 1 : 1 / fa;
+    return { left: (1 - width) / 2, top: (1 - height) / 2, width, height };
+}
+export function moveCrop(crop, dx, dy) {
+    return {
+        ...crop,
+        left: Math.min(Math.max(crop.left + dx, 0), 1 - crop.width),
+        top: Math.min(Math.max(crop.top + dy, 0), 1 - crop.height),
+    };
+}
+export function resizeCrop(crop, handle, dx, dy, lock, min = MIN_SIDE) {
+    const right = crop.left + crop.width, bottom = crop.top + crop.height;
+    const ax = handle.includes("w") ? right : crop.left; // anchor: the opposite corner
+    const ay = handle.includes("n") ? bottom : crop.top;
+    const mx = clamp01((handle.includes("w") ? crop.left : right) + dx);
+    const my = clamp01((handle.includes("n") ? crop.top : bottom) + dy);
+    // Signed: a corner dragged past its anchor collapses to `min`, never flips.
+    let width = Math.max(handle.includes("w") ? ax - mx : mx - ax, min);
+    let height = Math.max(handle.includes("n") ? ay - my : my - ay, min);
+    const roomX = handle.includes("w") ? ax : 1 - ax; // how far the moving corner may go
+    const roomY = handle.includes("n") ? ay : 1 - ay;
+    if (lock !== undefined) {
+        height = width / lock;
+        if (height > roomY) {
+            height = roomY;
+            width = height * lock;
+        }
+        if (width > roomX) {
+            width = roomX;
+            height = width / lock;
+        }
+        if (height < min) {
+            height = min;
+            width = height * lock;
+        }
+    }
+    else {
+        width = Math.min(width, roomX);
+        height = Math.min(height, roomY);
+    }
+    return {
+        left: handle.includes("w") ? ax - width : ax,
+        top: handle.includes("n") ? ay - height : ay,
+        width, height,
+    };
+}
+export function placeHotspot(h, crop) {
+    return {
+        x: Math.min(Math.max(h.x, crop.left), crop.left + crop.width),
+        y: Math.min(Math.max(h.y, crop.top), crop.top + crop.height),
+    };
+}
+const atRatio = (crop, lock) => Math.abs(crop.width / crop.height - lock) < 1e-3;
+export function relock(state, aspect, imageAspect) {
+    if (aspect === undefined)
+        return { crop: state.crop, hotspot: placeHotspot(state.hotspot, state.crop) };
+    const lock = aspect / imageAspect;
+    const crop = atRatio(state.crop, lock) ? state.crop : fitAspect(aspect, imageAspect);
+    return { crop, hotspot: placeHotspot(state.hotspot, crop) };
+}
+export function initialState(value, aspect, imageAspect) {
+    return relock({ crop: value?.crop ?? FULL_CROP, hotspot: value?.hotspot ?? CENTER_HOTSPOT }, aspect, imageAspect);
+}

package/dist/admin/forms/measure.d.ts

@@ -0,0 +1,2 @@
+import type { Measured } from "./upload.ts";
+export declare function measureFile(file: Blob, mime: string): Promise<Measured>;

package/dist/admin/forms/measure.js

@@ -0,0 +1,39 @@
+const objectUrl = (file) => URL.createObjectURL(file);
+function measureImage(file) {
+    return new Promise((resolve) => {
+        const url = objectUrl(file);
+        const img = new Image();
+        img.onload = () => { resolve({ width: img.naturalWidth, height: img.naturalHeight }); URL.revokeObjectURL(url); };
+        img.onerror = () => { resolve({}); URL.revokeObjectURL(url); };
+        img.src = url;
+    });
+}
+function measureVideo(file) {
+    return new Promise((resolve) => {
+        const url = objectUrl(file);
+        const video = document.createElement("video");
+        video.preload = "metadata";
+        video.muted = true;
+        const done = (m) => { resolve(m); URL.revokeObjectURL(url); };
+        video.onerror = () => done({});
+        video.onloadedmetadata = () => {
+            const base = { width: video.videoWidth, height: video.videoHeight, duration: video.duration };
+            video.onseeked = () => {
+                const canvas = document.createElement("canvas");
+                canvas.width = video.videoWidth;
+                canvas.height = video.videoHeight;
+                canvas.getContext("2d")?.drawImage(video, 0, 0);
+                canvas.toBlob((blob) => done(blob ? { ...base, poster: blob } : base), "image/jpeg", 0.85);
+            };
+            video.currentTime = Math.min(1, video.duration / 2);
+        };
+        video.src = url;
+    });
+}
+export function measureFile(file, mime) {
+    if (mime.startsWith("image/"))
+        return measureImage(file);
+    if (mime.startsWith("video/"))
+        return measureVideo(file);
+    return Promise.resolve({});
+}

package/dist/admin/forms/richtext-extensions.d.ts

@@ -0,0 +1,5 @@
+import { type AnyExtension } from "@tiptap/core";
+import type { Allowed } from "../../toolset.ts";
+export declare function richtextExtensions(allowed: Allowed, hooks: {
+    onLink(): void;
+}): AnyExtension[];

package/dist/admin/forms/richtext-extensions.js

@@ -0,0 +1,74 @@
+// The editor's extension set (spec 2026-09-08 §2): always the FULL schema
+// of what `RichText` draws, so content a toolset forbids survives the
+// round trip; the toolset gates only creation — input rules, paste rules
+// and keyboard shortcuts here, the toolbar in RichtextToolbar, paste in
+// richtext-paste. StarterKit supplies document, paragraph, text, hard
+// break, list item, list keymap and undo/redo; every gated node or mark
+// is switched off there and added back extended.
+import { Extension, textblockTypeInputRule } from "@tiptap/core";
+import StarterKit from "@tiptap/starter-kit";
+import Heading from "@tiptap/extension-heading";
+import Bold from "@tiptap/extension-bold";
+import Italic from "@tiptap/extension-italic";
+import Link from "@tiptap/extension-link";
+import Blockquote from "@tiptap/extension-blockquote";
+import { BulletList, OrderedList } from "@tiptap/extension-list";
+/** Keep the mark in the schema; add no way to create it when `on` is false. */
+function gateMarkConfig(on) {
+    return {
+        addInputRules() { return on ? this.parent?.() ?? [] : []; },
+        addPasteRules() { return on ? this.parent?.() ?? [] : []; },
+        addKeyboardShortcuts() { return on ? this.parent?.() ?? {} : {}; },
+    };
+}
+function gateNodeConfig(on) {
+    return {
+        addInputRules() { return on ? this.parent?.() ?? [] : []; },
+        addPasteRules() { return on ? this.parent?.() ?? [] : []; },
+        addKeyboardShortcuts() { return on ? this.parent?.() ?? {} : {}; },
+    };
+}
+const ALL_LEVELS = [1, 2, 3, 4, 5, 6];
+export function richtextExtensions(allowed, hooks) {
+    const link = allowed.marks.has("link");
+    const levels = allowed.headingLevels;
+    return [
+        StarterKit.configure({
+            heading: false, bold: false, italic: false, link: false, blockquote: false,
+            bulletList: false, orderedList: false,
+            code: false, codeBlock: false, strike: false, underline: false, horizontalRule: false,
+            dropcursor: false, gapcursor: false, trailingNode: false,
+        }),
+        Heading.extend({
+            // Exact `#` counts, and only the allowed levels; `# ` does nothing when h1 is forbidden.
+            addInputRules() {
+                return levels.map((level) => textblockTypeInputRule({ find: new RegExp(`^(#{${level}})\\s$`), type: this.type, getAttributes: { level } }));
+            },
+            addKeyboardShortcuts() {
+                return Object.fromEntries(levels.map((level) => [`Mod-Alt-${level}`, () => this.editor.commands.toggleHeading({ level })]));
+            },
+        }).configure({ levels: ALL_LEVELS }),
+        Bold.extend(gateMarkConfig(allowed.marks.has("bold"))),
+        Italic.extend(gateMarkConfig(allowed.marks.has("italic"))),
+        Link.extend({
+            ...gateMarkConfig(link),
+            // href only (spec §3): no target, rel or class in the stored JSON.
+            addAttributes() { return { href: { default: null } }; },
+        }).configure({
+            openOnClick: false,
+            autolink: link,
+            linkOnPaste: link,
+            // Site-relative targets are links too; the site renderer's scheme filter is the safety net.
+            isAllowedUri: (url, ctx) => /^[/#?.]/.test(url) || ctx.defaultValidate(url),
+        }),
+        Blockquote.extend(gateNodeConfig(allowed.nodes.has("blockquote"))),
+        BulletList.extend(gateNodeConfig(allowed.nodes.has("bulletList"))),
+        OrderedList.extend(gateNodeConfig(allowed.nodes.has("orderedList"))),
+        Extension.create({
+            name: "smoodlyLinkShortcut",
+            addKeyboardShortcuts() {
+                return link ? { "Mod-k": () => { hooks.onLink(); return true; } } : {};
+            },
+        }),
+    ];
+}

package/dist/admin/forms/richtext-paste.d.ts

@@ -0,0 +1,22 @@
+import type { Allowed } from "../../toolset.ts";
+export type PmJSON = {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: PmJSON[];
+    text?: string;
+    marks?: {
+        type: string;
+        attrs?: Record<string, unknown>;
+    }[];
+};
+/** ProseMirror's Slice.toJSON() shape. */
+export type SliceJSON = {
+    content?: PmJSON[] | null;
+    openStart?: number;
+    openEnd?: number;
+};
+/** The allowed level closest to `level`; the smaller number on a tie;
+ *  null when no heading is allowed. */
+export declare function clampLevel(level: number, levels: number[]): number | null;
+export declare function gateNodes(nodes: PmJSON[], allowed: Allowed): PmJSON[];
+export declare function gatePastedSlice(slice: SliceJSON, allowed: Allowed): SliceJSON;

package/dist/admin/forms/richtext-paste.js

@@ -0,0 +1,59 @@
+/** The allowed level closest to `level`; the smaller number on a tie;
+ *  null when no heading is allowed. */
+export function clampLevel(level, levels) {
+    if (levels.length === 0)
+        return null;
+    let best = levels[0];
+    for (const l of levels) {
+        const d = Math.abs(l - level);
+        const bd = Math.abs(best - level);
+        if (d < bd || (d === bd && l < best))
+            best = l;
+    }
+    return best;
+}
+export function gateNodes(nodes, allowed) {
+    return nodes.flatMap((n) => gateNode(n, allowed));
+}
+function gateNode(n, allowed) {
+    if (n.type === "text") {
+        const marks = (n.marks ?? []).filter((m) => allowed.marks.has(m.type));
+        const { marks: _drop, ...rest } = n;
+        return [marks.length > 0 ? { ...rest, marks } : rest];
+    }
+    const content = n.content ? gateNodes(n.content, allowed) : undefined;
+    const withContent = (node) => (content ? { ...node, content } : node);
+    if (n.type === "heading") {
+        const level = clampLevel(Number(n.attrs?.level ?? 1), allowed.headingLevels);
+        if (level === null)
+            return [withContent({ type: "paragraph" })];
+        return [withContent({ ...n, attrs: { ...n.attrs, level } })];
+    }
+    if (n.type === "blockquote" && !allowed.nodes.has("blockquote"))
+        return content ?? [];
+    if ((n.type === "bulletList" && !allowed.nodes.has("bulletList")) || (n.type === "orderedList" && !allowed.nodes.has("orderedList"))) {
+        return (content ?? []).flatMap((item) => item.content ?? []);
+    }
+    return [withContent(n)];
+}
+/** Depth of the first (or last) child chain, counting every non-text node. */
+function edgeDepth(nodes, side) {
+    let depth = 0;
+    let list = nodes;
+    while (list.length > 0) {
+        const n = side === "first" ? list[0] : list[list.length - 1];
+        if (n.type === "text")
+            break;
+        depth++;
+        list = n.content ?? [];
+    }
+    return depth;
+}
+export function gatePastedSlice(slice, allowed) {
+    const content = gateNodes(slice.content ?? [], allowed);
+    return {
+        content,
+        openStart: Math.min(slice.openStart ?? 0, edgeDepth(content, "first")),
+        openEnd: Math.min(slice.openEnd ?? 0, edgeDepth(content, "last")),
+    };
+}

package/dist/admin/forms/upload.d.ts

@@ -0,0 +1,17 @@
+import type { AdminOps, OpResult } from "../ops.ts";
+import { type AssetRecord } from "../../media.ts";
+export type Measured = {
+    width?: number;
+    height?: number;
+    duration?: number;
+    poster?: Blob;
+};
+export type UploadDeps = {
+    put(url: string, file: Blob, mime: string): Promise<void>;
+    measure(file: Blob, mime: string): Promise<Measured>;
+};
+export declare function uploadFile(ops: AdminOps["assets"], file: File, deps: UploadDeps): Promise<OpResult<AssetRecord>>;
+/** A raw PUT to the signed URL: the body is the file, the type its mime,
+ *  and the year-long cache-control Storage serves back (without the
+ *  header a signed upload lands as `no-cache`). */
+export declare function putSigned(url: string, file: Blob, mime: string): Promise<void>;

package/dist/admin/forms/upload.js

@@ -0,0 +1,33 @@
+import { MEDIA_CACHE_SECONDS } from "../../media.js";
+const stem = (name) => name.replace(/\.[^.]+$/, "");
+export async function uploadFile(ops, file, deps) {
+    const begun = await ops.beginUpload({ name: file.name, mime: file.type, size: file.size });
+    if (!begun.ok)
+        return begun;
+    try {
+        await deps.put(begun.data.uploadUrl, file, file.type);
+    }
+    catch (e) {
+        return { ok: false, code: "internal", message: `smoodly: upload failed — ${e instanceof Error ? e.message : String(e)}` };
+    }
+    const m = await deps.measure(file, file.type);
+    let posterId;
+    if (m.poster) {
+        const poster = await uploadFile(ops, new File([m.poster], `${stem(file.name)}-poster.jpg`, { type: "image/jpeg" }), deps);
+        if (poster.ok)
+            posterId = poster.data.id;
+    }
+    return ops.finishUpload(begun.data.id, { width: m.width, height: m.height, duration: m.duration, posterId });
+}
+/** A raw PUT to the signed URL: the body is the file, the type its mime,
+ *  and the year-long cache-control Storage serves back (without the
+ *  header a signed upload lands as `no-cache`). */
+export async function putSigned(url, file, mime) {
+    const res = await fetch(url, {
+        method: "PUT",
+        headers: { "content-type": mime, "x-upsert": "false", "cache-control": `max-age=${MEDIA_CACHE_SECONDS}` },
+        body: file,
+    });
+    if (!res.ok)
+        throw new Error(`${res.status} ${(await res.text()).slice(0, 200)}`);
+}

package/dist/admin/index.d.ts

@@ -1,4 +1,4 @@
-export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, SharedListItem, SharedGetResult } from "./ops.ts";
+export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError, PageCreateInput, PageGetResult, SharedListItem, SharedGetResult, AssetUsageItem } 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";
@@ -9,4 +9,3 @@ export { serializeAdminConfig } 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

@@ -7,4 +7,3 @@ export { supabaseAdminAuth } from "./supabase-auth.js";
 export { serializeAdminConfig } from "./serialize.js";
 export * from "./tree-ops.js";
 export { validateFields } from "./validate.js";
-export { plainToRichtext, richtextToPlain } from "./richtext.js";

package/dist/admin/next/create-admin.d.ts

@@ -1,4 +1,4 @@
-import type { ReactElement, ReactNode } from "react";
+import type { ReactNode } from "react";
 import type { ResolvedConfig } from "../../config.ts";
 import type { AdminOpAction } from "../ops.ts";
 import type { AuthConfig } from "../shell/session.ts";
@@ -7,12 +7,8 @@ export declare function createSmoodlyAdmin(input: {
     op: AdminOpAction;
     auth: () => AuthConfig;
 }): {
-    AdminPage: ({ params }: {
-        params: Promise<{
-            segments?: string[];
-        }>;
-    }) => Promise<ReactElement>;
+    AdminPage: () => null;
     AdminLayout: ({ children }: {
         children: ReactNode;
-    }) => ReactElement;
+    }) => import("react").JSX.Element;
 };

package/dist/admin/next/create-admin.js

@@ -4,16 +4,25 @@ import { AdminApp } from "../shell/AdminApp.js";
 import { AdminStyles } from "../ui/theme.js";
 export function createSmoodlyAdmin(input) {
     const registry = serializeAdminConfig(input.config);
-    async function AdminPage({ params }) {
-        const { segments = [] } = await params;
-        return _jsx(AdminApp, { registry: registry, segments: segments, op: input.op, auth: input.auth() });
+    /** The catch-all page only makes every /admin URL exist. The shell is
+     *  mounted by the layout, not here: a server action that revalidates
+     *  (publish, delete, a save of published content) answers with a
+     *  re-rendered tree for the URL it was posted to, and Next remounts a
+     *  page whose dynamic segment changed since the document load, while a
+     *  layout persists (spec 2026-09-08 client routing, §1 amendment). */
+    function AdminPage() {
+        return null;
     }
     /** The admin owns the viewport: the whole UI is a fixed three-column
      *  shell that scrolls internally, never the host document. The design
      *  system's tokens ride along in one <style> — the host app imports
-     *  nothing (see ui/theme.tsx). */
+     *  nothing (see ui/theme.tsx). The shell reads its route from the URL
+     *  on mount (shell/router.ts); `children` is the page's nothing.
+     *  suppressHydrationWarning: the theme boot script sets `data-theme`
+     *  on this element before React hydrates, on purpose (no white flash
+     *  for a dark-mode editor), so the attribute differs from the server's. */
     function AdminLayout({ children }) {
-        return (_jsxs("div", { className: "sm-admin", children: [_jsx(AdminStyles, {}), children] }));
+        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth() }), children] }));
     }
     return { AdminPage, AdminLayout };
 }

package/dist/admin/next/op-handler.d.ts

@@ -1,6 +1,7 @@
 import type { ResolvedConfig } from "../../config.ts";
 import type { EntryStore } from "../../entry-store.ts";
 import type { PageStore } from "../../store.ts";
+import type { AssetStore } from "../../asset-store.ts";
 import { type AdminAuth } from "../auth.ts";
 import type { AdminOpAction } from "../ops.ts";
 export declare function createAdminOpHandler(deps: {
@@ -9,4 +10,6 @@ export declare function createAdminOpHandler(deps: {
     entries: EntryStore;
     auth: AdminAuth;
     href?: (path: string, locale: string) => string;
+    /** The media library; without it the assets ops answer "no media store". */
+    assets?: AssetStore;
 }): AdminOpAction;

package/dist/admin/next/op-handler.js

@@ -12,6 +12,7 @@ export function createAdminOpHandler(deps) {
         pages: deps.pages,
         entries: deps.entries,
         href: deps.href,
+        assets: deps.assets,
         effects: {
             // updateTag, not revalidateTag(tag, profile): the profile form is
             // stale-while-revalidate, so the first request after publish still

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

@@ -1,5 +1,6 @@
 import type { ResolvedConfig } from "../config.ts";
 import type { EntryStore } from "../entry-store.ts";
+import type { AssetStore } from "../asset-store.ts";
 import type { PageStore } from "../store.ts";
 import type { AdminOpCall, AdminOps, OpResult } from "./ops.ts";
 export type AdminEffects = {
@@ -17,6 +18,8 @@ export declare function createAdminOps(deps: {
     effects?: AdminEffects;
     /** Locale-relative CMS path → site URL (the renderer's seam, applied here for the admin). Default: identity. */
     href?: (path: string, locale: string) => string;
+    /** The media library; absent = every assets op answers "no media store". */
+    assets?: AssetStore;
 }): AdminOps;
 /** Path-dispatch for the one-server-action seam. Own-property checks only —
  * "constructor.constructor" and prototype paths must not resolve. */