smoodly 0.0.1

package/dist/admin/forms/FieldWidget.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { plainToRichtext, richtextToPlain } from "../richtext.js";
+const label = (key) => key.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase());
+const inputStyle = {
+    width: "100%", boxSizing: "border-box", border: "1px solid #d6d3e0", borderRadius: 8,
+    padding: "9px 10px", fontFamily: "inherit", fontSize: 13.5, background: "#fff", color: "#17141f",
+};
+export function FieldWidget({ descriptor: d, value, onChange, error, refOptions = [], fieldKey, }) {
+    const optionTitle = (o) => o.status === "draft" ? `${o.title} (draft)` : o.title;
+    let control;
+    switch (d.type) {
+        case "text":
+        case "link":
+        case "slug":
+        case "date":
+            control = _jsx("input", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value) });
+            break;
+        case "number":
+            control = (_jsx("input", { style: inputStyle, type: "number", value: value == null ? "" : String(value), onChange: (e) => onChange(e.target.value === "" ? undefined : Number(e.target.value)) }));
+            break;
+        case "select": {
+            const options = Array.isArray(d.options) ? d.options : [];
+            control = (_jsxs("select", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value), children: [d.optional === true && _jsx("option", { value: "", children: "\u2014" }), options.map((o) => _jsx("option", { value: o, children: o }, o))] }));
+            break;
+        }
+        case "richtext":
+            control = (_jsx("textarea", { style: { ...inputStyle, resize: "vertical" }, rows: 4, value: richtextToPlain(value), onChange: (e) => onChange(plainToRichtext(e.target.value)) }));
+            break;
+        case "image":
+        case "video":
+        case "file": {
+            const url = value?.url ?? "";
+            control = (_jsx("input", { style: inputStyle, placeholder: "https://\u2026", value: url, onChange: (e) => onChange(e.target.value ? { url: e.target.value } : undefined) }));
+            break;
+        }
+        case "ref":
+            control = (_jsxs("select", { style: inputStyle, value: String(value ?? ""), onChange: (e) => onChange(e.target.value || undefined), children: [_jsx("option", { value: "", children: "\u2014" }), refOptions.map((o) => _jsx("option", { value: o.id, children: optionTitle(o) }, o.id))] }));
+            break;
+        case "refList": {
+            const ids = Array.isArray(value) ? value : [];
+            const byId = new Map(refOptions.map((o) => [o.id, o]));
+            control = (_jsxs("div", { children: [ids.map((id, i) => (_jsxs("div", { style: { display: "flex", gap: 6, marginBottom: 6 }, children: [_jsx("span", { style: { ...inputStyle, flex: 1 }, children: byId.get(id) ? optionTitle(byId.get(id)) : id }), _jsx("button", { type: "button", onClick: () => onChange(ids.filter((_, j) => j !== i)), style: { border: 0, background: "#efecf6", borderRadius: 8, cursor: "pointer", padding: "0 10px" }, children: "\u2715" })] }, `${id}-${i}`))), _jsxs("select", { style: inputStyle, value: "", onChange: (e) => e.target.value && onChange([...ids, e.target.value]), children: [_jsx("option", { value: "", children: "Add\u2026" }), refOptions.filter((o) => !ids.includes(o.id)).map((o) => (_jsx("option", { value: o.id, children: optionTitle(o) }, o.id)))] })] }));
+            break;
+        }
+        default:
+            control = _jsx("textarea", { style: inputStyle, disabled: true, value: JSON.stringify(value ?? null, null, 2), rows: 2 });
+    }
+    // A <label> activates its first labelable descendant, so it may only wrap a
+    // single control — around refList's rows it would turn every click into a
+    // press of the first row's remove button.
+    const Wrapper = d.type === "refList" ? "div" : "label";
+    return (_jsxs(Wrapper, { style: { display: "block", marginBottom: 14 }, children: [_jsx("span", { style: { display: "block", fontSize: 11, letterSpacing: "0.08em", textTransform: "uppercase", opacity: 0.55, marginBottom: 6 }, children: label(fieldKey) }), control, error && _jsx("span", { style: { display: "block", color: "#b91c1c", fontSize: 12, marginTop: 4 }, children: error })] }));
+}

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

@@ -0,0 +1,11 @@
+import type { AdminField, AdminSection } from "../serialize.ts";
+export type TabName = "Content" | "Styles" | "Media" | "Meta";
+export type TabEntry = {
+    key: string;
+    ns: "fields" | "styles" | "meta";
+    descriptor: AdminField;
+};
+export declare function tabsFor(section: AdminSection): {
+    tab: TabName;
+    entries: TabEntry[];
+}[];

package/dist/admin/forms/tabs.js

@@ -0,0 +1,20 @@
+const MEDIA_TYPES = new Set(["image", "video", "file"]);
+const TAB_BY_NS = {
+    fields: "Content", styles: "Styles", meta: "Meta",
+};
+const TAB_BY_OVERRIDE = {
+    content: "Content", styles: "Styles", media: "Media", meta: "Meta",
+};
+export function tabsFor(section) {
+    const buckets = { Content: [], Styles: [], Media: [], Meta: [] };
+    for (const ns of ["fields", "styles", "meta"]) {
+        for (const [key, descriptor] of Object.entries(section[ns] ?? {})) {
+            const override = typeof descriptor.tab === "string" ? TAB_BY_OVERRIDE[descriptor.tab] : undefined;
+            const tab = override ?? (MEDIA_TYPES.has(descriptor.type) ? "Media" : TAB_BY_NS[ns]);
+            buckets[tab].push({ key, ns, descriptor });
+        }
+    }
+    return ["Content", "Styles", "Media", "Meta"]
+        .filter((tab) => buckets[tab].length > 0)
+        .map((tab) => ({ tab, entries: buckets[tab] }));
+}

package/dist/admin/index.d.ts

@@ -0,0 +1,10 @@
+export type { AdminOps, AdminOpCall, AdminOpAction, OpResult, OpError } from "./ops.ts";
+export { createAdminOps, runAdminOp, type AdminEffects } from "./ops-impl.ts";
+export { makeClientOps } from "./client-ops.ts";
+export { gateAdminOp, type AdminAuth } from "./auth.ts";
+export { supabaseAdminAuth } from "./supabase-auth.ts";
+export { serializeAdminConfig } from "./serialize.ts";
+export type { AdminRegistry, AdminSection, AdminCollection, AdminPageTemplate, AdminField } from "./serialize.ts";
+export * from "./tree-ops.ts";
+export { validateFields, type FieldError } from "./validate.ts";
+export { plainToRichtext, richtextToPlain } from "./richtext.ts";

package/dist/admin/index.js

@@ -0,0 +1,8 @@
+export { createAdminOps, runAdminOp } from "./ops-impl.js";
+export { makeClientOps } from "./client-ops.js";
+export { gateAdminOp } from "./auth.js";
+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/bridge.d.ts

@@ -0,0 +1 @@
+export declare function EditorBridge(): null;

package/dist/admin/next/bridge.js

@@ -0,0 +1,66 @@
+"use client";
+// Runs INSIDE the draft-route iframe (glue adds it only when draft mode +
+// the editor param are on). Reports geometry, forwards select/hover,
+// executes refresh/scroll — the admin overlay draws all chrome. 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";
+export function EditorBridge() {
+    const router = useRouter();
+    useEffect(() => {
+        const post = (m) => window.parent.postMessage(m, "*");
+        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 = Array.from(document.querySelectorAll("[data-smoodly-node]")).map((el) => {
+                const r = el.getBoundingClientRect();
+                return { id: el.dataset.smoodlyNode, x: r.left + window.scrollX, y: r.top + window.scrollY, w: r.width, h: r.height };
+            });
+            const emptyZones = Array.from(document.querySelectorAll("[data-smoodly-zone]")).map((el) => {
+                const r = el.getBoundingClientRect();
+                return { zone: el.dataset.smoodlyZone, x: r.left + window.scrollX, y: r.top + window.scrollY, w: r.width, h: r.height };
+            });
+            post({ source: "smoodly", kind: "rects", nodes, emptyZones, docH: document.documentElement.scrollHeight });
+        };
+        const raf = () => requestAnimationFrame(report);
+        const ro = new ResizeObserver(raf);
+        ro.observe(document.documentElement);
+        const mo = new MutationObserver(raf);
+        mo.observe(document.body, { subtree: true, childList: true, attributes: true });
+        const nodeIdAt = (target) => target?.closest?.("[data-smoodly-node]")?.dataset.smoodlyNode ?? null;
+        const onClick = (e) => {
+            // The canvas must never navigate away from under the editor.
+            if (e.target?.closest?.("a"))
+                e.preventDefault();
+            post({ source: "smoodly", kind: "select", id: nodeIdAt(e.target) });
+        };
+        const onMove = (e) => post({ source: "smoodly", kind: "hover", id: nodeIdAt(e.target) });
+        const onMessage = (e) => {
+            const m = e.data;
+            if (m?.source !== "smoodly")
+                return;
+            if (m.kind === "refresh")
+                router.refresh();
+            if (m.kind === "scroll") {
+                document
+                    .querySelector(`[data-smoodly-node="${CSS.escape(m.id)}"]`)
+                    ?.scrollIntoView({ behavior: "smooth", block: "center" });
+            }
+        };
+        document.addEventListener("click", onClick, true);
+        document.addEventListener("mousemove", onMove, true);
+        window.addEventListener("message", onMessage);
+        report();
+        const late = setTimeout(report, 500); // fonts/images settle
+        return () => {
+            ro.disconnect();
+            mo.disconnect();
+            clearTimeout(late);
+            document.removeEventListener("click", onClick, true);
+            document.removeEventListener("mousemove", onMove, true);
+            window.removeEventListener("message", onMessage);
+        };
+    }, [router]);
+    return null;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { serializeAdminConfig } from "../serialize.js";
+import { AdminApp } from "../shell/AdminApp.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() });
+    }
+    function AdminLayout({ children }) {
+        return (_jsx("div", { style: { fontFamily: "system-ui, sans-serif", minHeight: "100vh", background: "#f4f3f8", color: "#17141f" }, children: children }));
+    }
+    return { AdminPage, AdminLayout };
+}

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

@@ -0,0 +1,6 @@
+export { createAdminOpHandler } from "./op-handler.ts";
+export { createSmoodlyAdmin } from "./create-admin.tsx";
+export type { AdminOpCall, AdminOpAction, AdminOps, OpResult } from "../ops.ts";
+export type { AuthConfig } from "../shell/session.ts";
+export type { AdminAuth } from "../auth.ts";
+export { supabaseAdminAuth } from "../supabase-auth.ts";

package/dist/admin/next/index.js

@@ -0,0 +1,3 @@
+export { createAdminOpHandler } from "./op-handler.js";
+export { createSmoodlyAdmin } from "./create-admin.js";
+export { supabaseAdminAuth } from "../supabase-auth.js";

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

@@ -0,0 +1,11 @@
+import type { ResolvedConfig } from "../../config.ts";
+import type { EntryStore } from "../../entry-store.ts";
+import type { PageStore } from "../../store.ts";
+import { type AdminAuth } from "../auth.ts";
+import type { AdminOpAction } from "../ops.ts";
+export declare function createAdminOpHandler(deps: {
+    config: ResolvedConfig;
+    pages: PageStore;
+    entries: EntryStore;
+    auth: AdminAuth;
+}): AdminOpAction;

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

@@ -0,0 +1,23 @@
+// packages/smoodly/src/admin/next/op-handler.ts
+// The Next face of the ops seam: ONE server-action body, gated by
+// AdminAuth. The app's 'use server' file wraps this in its single
+// exported async function.
+import { revalidateTag } from "next/cache";
+import { draftMode } from "next/headers";
+import { gateAdminOp } from "../auth.js";
+import { createAdminOps, runAdminOp } from "../ops-impl.js";
+export function createAdminOpHandler(deps) {
+    const ops = createAdminOps({
+        config: deps.config,
+        pages: deps.pages,
+        entries: deps.entries,
+        effects: {
+            revalidatePage: (slug) => revalidateTag(`page:${slug}`, "max"),
+            draft: {
+                enable: async () => (await draftMode()).enable(),
+                disable: async () => (await draftMode()).disable(),
+            },
+        },
+    });
+    return (call) => gateAdminOp(deps.auth, call, (c) => runAdminOp(ops, c));
+}

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

@@ -0,0 +1,20 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { EntryStore } from "../entry-store.ts";
+import type { PageStore } from "../store.ts";
+import type { AdminOpCall, AdminOps, OpResult } from "./ops.ts";
+export type AdminEffects = {
+    revalidatePage?(slug: string): void;
+    draft?: {
+        enable(): void | Promise<void>;
+        disable(): void | Promise<void>;
+    };
+};
+export declare function createAdminOps(deps: {
+    config: ResolvedConfig;
+    pages: PageStore;
+    entries: EntryStore;
+    effects?: AdminEffects;
+}): AdminOps;
+/** Path-dispatch for the one-server-action seam. Own-property checks only —
+ * "constructor.constructor" and prototype paths must not resolve. */
+export declare function runAdminOp(ops: AdminOps, call: AdminOpCall): Promise<OpResult<unknown>>;

package/dist/admin/ops-impl.js

@@ -0,0 +1,189 @@
+import { affectedPageSlugs } from "../revalidate.js";
+import { validateFields } from "./validate.js";
+const ok = (data) => ({ ok: true, data });
+const err = (code, message, fields) => ({ ok: false, code, message, ...(fields ? { fields } : {}) });
+/** Own-property, non-array plain object — same shape guard the tree checks
+ * below and `runAdminOp`'s envelope check both lean on. */
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/** A client-submitted tree is untyped data until proven otherwise — a
+ * malformed shape here would corrupt the stored draft and crash every
+ * later reader (canvas, publish-integrity walk). Structural only: does
+ * not validate per-section field schemas (that's publish's job). */
+function isPageTree(tree) {
+    if (!isPlainObject(tree) || !isPlainObject(tree.zones))
+        return false;
+    if (tree.meta !== undefined && !isPlainObject(tree.meta))
+        return false;
+    for (const nodes of Object.values(tree.zones)) {
+        if (!Array.isArray(nodes))
+            return false;
+        for (const node of nodes) {
+            if (!isPlainObject(node))
+                return false;
+            if (typeof node.id !== "string" || typeof node.type !== "string")
+                return false;
+        }
+    }
+    return true;
+}
+/** 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"))
+        return err("conflict", message);
+    if (message.includes("is referenced by"))
+        return err("blocked", message);
+    if (message.includes("cannot publish"))
+        return err("blocked", message);
+    if (message.includes("no page") || message.includes("no entry") || message.includes("no collection"))
+        return err("not_found", message);
+    return err("internal", message);
+};
+export function createAdminOps(deps) {
+    const { config, pages, entries, effects } = deps;
+    const collectionFields = (name) => config.registry.collections?.find((c) => c.name === name)?.fields ?? null;
+    const sectionFields = (type) => config.registry.sections?.find((s) => s.schema.name === type)?.schema;
+    const fanOut = async (entryId) => {
+        if (!effects?.revalidatePage)
+            return;
+        for (const slug of await affectedPageSlugs({ pages, entries }, entryId)) {
+            effects.revalidatePage(slug);
+        }
+    };
+    const guard = async (work) => {
+        try {
+            return await work();
+        }
+        catch (e) {
+            return classify(e);
+        }
+    };
+    return {
+        pages: {
+            list: () => guard(async () => ok(await pages.listPages())),
+            get: (slug) => guard(async () => {
+                const record = await pages.getPage(slug);
+                const draft = record ? await pages.getDraftTree(slug) : null;
+                if (!record || !draft)
+                    return err("not_found", `smoodly: no page with slug "${slug}".`);
+                return ok({ record, draft });
+            }),
+            create: (input) => guard(async () => {
+                const registration = config.registry.pages?.find((p) => p.schema.name === input.template);
+                if (!registration) {
+                    return err("validation", `smoodly: no page template named "${input.template}".`);
+                }
+                const fixed = registration.schema.slug;
+                if (fixed !== undefined && fixed !== input.slug) {
+                    return err("validation", `smoodly: page template "${input.template}" is fixed to the slug "${fixed}" and cannot be created at "${input.slug}".`);
+                }
+                if (fixed === undefined) {
+                    // An open page here would be shadowed forever by the fixed
+                    // registration's own route file.
+                    const owner = config.registry.pages?.find((p) => p.schema.slug === input.slug);
+                    if (owner) {
+                        return err("validation", `smoodly: the slug "${input.slug}" belongs to the page template "${owner.schema.name}" and its own route file.`);
+                    }
+                }
+                return ok(await pages.createPage(input));
+            }),
+            saveDraft: (slug, tree) => guard(async () => {
+                if (!isPageTree(tree))
+                    return err("validation", "smoodly: malformed page tree.");
+                return ok({ versionId: (await pages.saveDraft(slug, tree)).id });
+            }),
+            publish: (slug) => guard(async () => {
+                const draft = await pages.getDraftTree(slug);
+                if (!draft)
+                    return err("not_found", `smoodly: no page with slug "${slug}".`);
+                const fieldErrors = [];
+                for (const nodes of Object.values(draft.zones)) {
+                    for (const node of nodes) {
+                        const schema = sectionFields(node.type);
+                        if (!schema?.fields)
+                            continue;
+                        for (const fe of validateFields(node.fields ?? {}, schema.fields)) {
+                            fieldErrors.push({ field: `${node.id}.${fe.field}`, message: fe.message });
+                        }
+                    }
+                }
+                if (fieldErrors.length > 0) {
+                    return err("validation", `smoodly: cannot publish "${slug}" — fix the listed fields first.`, fieldErrors);
+                }
+                const record = await pages.publish(slug);
+                effects?.revalidatePage?.(slug);
+                return ok(record);
+            }),
+            delete: (slug) => guard(async () => {
+                const record = await pages.getPage(slug);
+                if (record) {
+                    // Blocked only when this record IS the registration's singleton.
+                    // A record whose template is fixed but which sits at another slug
+                    // (the route file's slug was renamed under it) is reachable at no
+                    // URL — blocking it would strand it forever.
+                    const registration = config.registry.pages?.find((p) => p.schema.name === record.template);
+                    if (registration && registration.schema.slug === record.slug) {
+                        return err("blocked", `smoodly: "${slug}" is a fixed page owned by the "${record.template}" route file — remove the route file to remove it.`);
+                    }
+                }
+                await pages.deletePage(slug);
+                return ok(null);
+            }),
+        },
+        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}".`);
+            }),
+            create: (collection, fields) => guard(async () => {
+                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);
+                return ok(await entries.create(collection, fields));
+            }),
+            save: (collection, id, fields) => guard(async () => {
+                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);
+                await fanOut(id);
+                return ok(entry);
+            }),
+            setStatus: (collection, id, status) => guard(async () => {
+                const entry = await entries.setStatus(collection, id, status);
+                await fanOut(id);
+                return ok(entry);
+            }),
+            delete: (collection, id) => guard(async () => (await entries.delete(collection, id), ok(null))),
+        },
+        preview: {
+            enable: () => guard(async () => (await effects?.draft?.enable(), ok(null))),
+            disable: () => guard(async () => (await effects?.draft?.disable(), ok(null))),
+        },
+    };
+}
+/** Path-dispatch for the one-server-action seam. Own-property checks only —
+ * "constructor.constructor" and prototype paths must not resolve. */
+export async function runAdminOp(ops, call) {
+    if (!isPlainObject(call) || typeof call.path !== "string" || !Array.isArray(call.args)) {
+        return { ok: false, code: "not_found", message: "smoodly: malformed op call." };
+    }
+    const [group, method, ...rest] = call.path.split(".");
+    const groupObj = rest.length === 0 && group && Object.prototype.hasOwnProperty.call(ops, group)
+        ? ops[group]
+        : undefined;
+    const fn = groupObj && method && Object.prototype.hasOwnProperty.call(groupObj, method)
+        ? groupObj[method]
+        : undefined;
+    if (typeof fn !== "function") {
+        return { ok: false, code: "not_found", message: `smoodly: unknown op "${call.path}".` };
+    }
+    return fn(...call.args);
+}

package/dist/admin/ops.d.ts

@@ -0,0 +1,52 @@
+import type { PageRecord } from "../store.ts";
+import type { PageTree } from "../render.tsx";
+import type { EntryRecord } from "../entry-store.ts";
+import type { FieldError } from "./validate.ts";
+export type OpError = {
+    ok: false;
+    code: "not_found" | "conflict" | "blocked" | "validation" | "internal" | "unauthorized";
+    message: string;
+    fields?: FieldError[];
+};
+export type OpResult<T> = {
+    ok: true;
+    data: T;
+} | OpError;
+export type AdminOps = {
+    pages: {
+        list(): Promise<OpResult<PageRecord[]>>;
+        get(slug: string): Promise<OpResult<{
+            record: PageRecord;
+            draft: PageTree;
+        }>>;
+        create(input: {
+            slug: string;
+            template: string;
+        }): Promise<OpResult<PageRecord>>;
+        saveDraft(slug: string, tree: PageTree): Promise<OpResult<{
+            versionId: string;
+        }>>;
+        publish(slug: string): Promise<OpResult<PageRecord>>;
+        delete(slug: string): Promise<OpResult<null>>;
+    };
+    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>>;
+        delete(collection: string, id: string): Promise<OpResult<null>>;
+    };
+    preview: {
+        enable(): Promise<OpResult<null>>;
+        disable(): Promise<OpResult<null>>;
+    };
+};
+/** `token`: the editor's Supabase Auth session token, attached by the
+ *  client facade and verified by the server gate (admin/auth.ts). */
+export type AdminOpCall = {
+    path: string;
+    args: unknown[];
+    token?: string;
+};
+export type AdminOpAction = (call: AdminOpCall) => Promise<OpResult<unknown>>;

package/dist/admin/ops.js

@@ -0,0 +1 @@
+export {};

package/dist/admin/page-path.d.ts

@@ -0,0 +1 @@
+export declare function pagePath(slug: string, homePageSlug: string): string;

package/dist/admin/page-path.js

@@ -0,0 +1,6 @@
+// The one place the admin turns a page slug into the site URL that serves
+// it. The root's slug is config (`homePageSlug`), not a convention the
+// package guesses at; a registration-declared path is the logged follow-up.
+export function pagePath(slug, homePageSlug) {
+    return slug === homePageSlug ? "/" : `/${slug}`;
+}

package/dist/admin/richtext.d.ts

@@ -0,0 +1,14 @@
+type TextNode = {
+    type: "text";
+    text: string;
+};
+type Paragraph = {
+    type: "paragraph";
+    content?: TextNode[];
+};
+export declare function richtextToPlain(doc: unknown): string;
+export declare function plainToRichtext(text: string): {
+    type: "doc";
+    content: Paragraph[];
+};
+export {};

package/dist/admin/richtext.js

@@ -0,0 +1,17 @@
+export function richtextToPlain(doc) {
+    const d = doc;
+    if (!d || d.type !== "doc" || !Array.isArray(d.content))
+        return "";
+    return d.content
+        .map((p) => (p.content ?? []).map((t) => t.text ?? "").join(""))
+        .join("\n");
+}
+export function plainToRichtext(text) {
+    return {
+        type: "doc",
+        content: text.split("\n").map((line) => ({
+            type: "paragraph",
+            ...(line ? { content: [{ type: "text", text: line }] } : {}),
+        })),
+    };
+}

package/dist/admin/serialize.d.ts

@@ -0,0 +1,40 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { ZonePolicy } from "../zones.ts";
+export type AdminField = Record<string, unknown> & {
+    type: string;
+    target?: string;
+};
+export type AdminSection = {
+    name: string;
+    title: string;
+    icon?: string;
+    description?: string;
+    fields: Record<string, AdminField>;
+    styles: Record<string, AdminField>;
+    meta: Record<string, AdminField>;
+    sample?: Record<string, unknown>;
+};
+export type AdminCollection = {
+    name: string;
+    title: string;
+    titleField?: string;
+    fields: Record<string, AdminField>;
+};
+export type AdminPageTemplate = {
+    name: string;
+    title: string;
+    slug?: string;
+    zones: Record<string, ZonePolicy>;
+};
+export type AdminRegistry = {
+    sections: AdminSection[];
+    collections: AdminCollection[];
+    pages: AdminPageTemplate[];
+    locales: {
+        default: string;
+        supported: string[];
+    };
+    /** Which slug the site root serves — see pagePath(). */
+    homePageSlug: string;
+};
+export declare function serializeAdminConfig(config: ResolvedConfig): AdminRegistry;