smoodly 0.0.1

package/dist/fields.js

@@ -0,0 +1,41 @@
+// Field builders — inert descriptors by design rule (see DESIGN.md §3):
+// f.text().max(40) is plain data; validation logic lives server/admin-side,
+// keyed by descriptor type. Chaining is immutable.
+function builder(descriptor) {
+    const chain = (patch) => builder({ ...descriptor, ...patch });
+    return {
+        descriptor,
+        optional: () => chain({ optional: true }),
+        localized: () => chain({ localized: true }),
+        max: (n) => chain({ max: n }),
+        min: (n) => chain({ min: n }),
+        default: (v) => chain({ default: v }),
+        resolve: (...projection) => {
+            if (projection.length === 0)
+                return chain({ resolve: "full" });
+            if (typeof projection[0] === "object")
+                return chain({ resolve: projection[0] });
+            return chain({ resolve: Object.fromEntries(projection.map((k) => [k, true])) });
+        },
+        tab: (tab) => chain({ tab }),
+    };
+}
+export const f = {
+    text: () => builder({ type: "text" }),
+    link: () => builder({ type: "link" }),
+    slug: (opts) => builder({ type: "slug", ...(opts?.from ? { from: opts.from } : {}) }),
+    date: () => builder({ type: "date" }),
+    number: () => builder({ type: "number" }),
+    image: () => builder({ type: "image" }),
+    video: () => builder({ type: "video" }),
+    file: () => builder({ type: "file" }),
+    richtext: (opts) => builder({ type: "richtext", ...(opts?.toolset !== undefined ? { toolset: opts.toolset } : {}) }),
+    dataAttributes: () => builder({ type: "dataAttributes" }),
+    select: (options) => builder({ type: "select", options: [...options] }),
+    object: (shape) => builder({
+        type: "object",
+        fields: Object.fromEntries(Object.entries(shape).map(([k, v]) => [k, v.descriptor])),
+    }),
+    ref: (target) => builder({ type: "ref", target }),
+    refList: (target) => builder({ type: "refList", target }),
+};

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import { section, element } from "./pairing.tsx";
+import { collection, toolset } from "./collections.ts";
+import { Section } from "./section-wrapper.tsx";
+import { page } from "./render.tsx";
+export { Zone, renderPage } from "./render.tsx";
+export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry } from "./render.tsx";
+export type { PageSchema } from "./page.ts";
+export { f } from "./fields.ts";
+export { z } from "./zones.ts";
+export { defineConfig } from "./config.ts";
+export { collectionSQL, coreTablesSQL } from "./sql.ts";
+export { MemoryPageStore } from "./store.ts";
+export { SupabasePageStore } from "./supabase-store.ts";
+export { collectEntryRefs, collectTreeRefs } from "./refs.ts";
+export type { RefEdge, SectionLike } from "./refs.ts";
+export { MemoryRefIndex } from "./ref-index.ts";
+export { MemoryEntryStore } from "./entry-store.ts";
+export { SupabaseEntryStore } from "./supabase-entry-store.ts";
+export type { EntryStore, EntryRecord, EntryUsage, ListOptions } from "./entry-store.ts";
+export { affectedPageSlugs } from "./revalidate.ts";
+export { resolveTree } from "./resolve.ts";
+export type { EntryFetcher } from "./resolve.ts";
+export type { PageStore, PageRecord, PageVersion, PageStoreOptions } from "./store.ts";
+export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
+export type { FieldBuilder, Descriptor, ValueOf } from "./fields.ts";
+export type { SectionSchema, ElementSchema, BuilderMap } from "./schema.ts";
+export type { Props, PairedComponent } from "./pairing.tsx";
+export type { CollectionSchema, Toolset } from "./collections.ts";
+export type { ZonePolicy } from "./zones.ts";
+export declare const smoodly: {
+    schema: {
+        page: typeof import("./page.ts").pageSchema;
+        section<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}, M extends import("./schema.ts").BuilderMap = {}>(input: {
+            name: string;
+            title: string;
+            icon?: string;
+            description?: string;
+            fields?: F | undefined;
+            styles?: S | undefined;
+            meta?: M | undefined;
+            sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K : never : never; }[keyof F]>]: import("./fields.ts").ValueOf<F[K_1]>; } & { [K_2 in { [K in keyof F]: F[K] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K : never : never; }[keyof F]]?: import("./fields.ts").ValueOf<F[K_2]> | undefined; } & { [K_4 in Exclude<keyof S, { [K_3 in keyof S]: S[K_3] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K_3 : never : never; }[keyof S]>]: import("./fields.ts").ValueOf<S[K_4]>; } & { [K_5 in { [K_3 in keyof S]: S[K_3] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
+            styleDefaults?: false | {
+                omit: string[];
+            };
+        }): import("./schema.ts").SectionSchema<F, S>;
+        element<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}, M extends import("./schema.ts").BuilderMap = {}>(input: {
+            name: string;
+            title: string;
+            icon?: string;
+            description?: string;
+            fields?: F | undefined;
+            styles?: S | undefined;
+            meta?: M | undefined;
+            sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K : never : never; }[keyof F]>]: import("./fields.ts").ValueOf<F[K_1]>; } & { [K_2 in { [K in keyof F]: F[K] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K : never : never; }[keyof F]]?: import("./fields.ts").ValueOf<F[K_2]> | undefined; } & { [K_4 in Exclude<keyof S, { [K_3 in keyof S]: S[K_3] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K_3 : never : never; }[keyof S]>]: import("./fields.ts").ValueOf<S[K_4]>; } & { [K_5 in { [K_3 in keyof S]: S[K_3] extends {
+                __flags?: infer Fl;
+            } ? Fl extends {
+                optional: true;
+            } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
+            styleDefaults?: false | {
+                omit: string[];
+            };
+        } & {
+            contexts: ("richtext" | "column")[];
+        }): import("./schema.ts").ElementSchema<F, S>;
+    };
+    section: typeof section;
+    element: typeof element;
+    page: typeof page;
+    collection: typeof collection;
+    toolset: typeof toolset;
+    Section: typeof Section;
+};
+export { resolveSmoodlyEnv, smoodlyEnv } from "./env.ts";
+export type { SmoodlyEnv } from "./env.ts";
+export { clientOptions, createSmoodlyClient } from "./client.ts";

package/dist/index.js

@@ -0,0 +1,29 @@
+import { schema } from "./schema.js";
+import { section, element } from "./pairing.js";
+import { collection, toolset } from "./collections.js";
+import { Section } from "./section-wrapper.js";
+import { page } from "./render.js";
+export { Zone, renderPage } from "./render.js";
+export { f } from "./fields.js";
+export { z } from "./zones.js";
+export { defineConfig } from "./config.js";
+export { collectionSQL, coreTablesSQL } from "./sql.js";
+export { MemoryPageStore } from "./store.js";
+export { SupabasePageStore } from "./supabase-store.js";
+export { collectEntryRefs, collectTreeRefs } from "./refs.js";
+export { MemoryRefIndex } from "./ref-index.js";
+export { MemoryEntryStore } from "./entry-store.js";
+export { SupabaseEntryStore } from "./supabase-entry-store.js";
+export { affectedPageSlugs } from "./revalidate.js";
+export { resolveTree } from "./resolve.js";
+export const smoodly = {
+    schema,
+    section,
+    element,
+    page,
+    collection,
+    toolset,
+    Section,
+};
+export { resolveSmoodlyEnv, smoodlyEnv } from "./env.js";
+export { clientOptions, createSmoodlyClient } from "./client.js";

package/dist/next/index.d.ts

@@ -0,0 +1,3 @@
+export { createPageRenderer } from "./page-renderer.tsx";
+export type { PageRendererOptions, RenderOptions } from "./page-renderer.tsx";
+export { pageSlugFor, metadataFrom } from "./meta.ts";

package/dist/next/index.js

@@ -0,0 +1,2 @@
+export { createPageRenderer } from "./page-renderer.js";
+export { pageSlugFor, metadataFrom } from "./meta.js";

package/dist/next/meta.d.ts

@@ -0,0 +1,10 @@
+import type { Metadata } from "next";
+import type { PageSchema } from "../page.ts";
+/** A route either carries a fixed registration (slug on the schema) or
+ * passes the slug from its params. Having neither is a developer wiring
+ * error, not runtime data — so this throws rather than returning a
+ * result. */
+export declare function pageSlugFor(schema: PageSchema<any>, explicit?: string): string;
+/** Maps the page tree's meta bag onto Next metadata. Absent meta returns
+ * {} so the app's own layout.tsx defaults apply untouched. */
+export declare function metadataFrom(meta: unknown): Metadata;

package/dist/next/meta.js

@@ -0,0 +1,37 @@
+/** A route either carries a fixed registration (slug on the schema) or
+ * passes the slug from its params. Having neither is a developer wiring
+ * error, not runtime data — so this throws rather than returning a
+ * result. */
+export function pageSlugFor(schema, explicit) {
+    if (explicit)
+        return explicit;
+    if (schema.slug)
+        return schema.slug;
+    throw new Error(`smoodly: page registration "${schema.name}" has no fixed slug — pass { slug } from the route's params to renderSmoodlyPage.`);
+}
+/** Maps the page tree's meta bag onto Next metadata. Absent meta returns
+ * {} so the app's own layout.tsx defaults apply untouched. */
+export function metadataFrom(meta) {
+    if (typeof meta !== "object" || meta === null || Array.isArray(meta))
+        return {};
+    const m = meta;
+    const str = (key) => (typeof m[key] === "string" && m[key] ? m[key] : undefined);
+    const title = str("title");
+    const description = str("description");
+    const ogImage = str("ogImage");
+    const out = {};
+    if (title)
+        out.title = title;
+    if (description)
+        out.description = description;
+    const og = {};
+    if (title)
+        og.title = title;
+    if (description)
+        og.description = description;
+    if (ogImage)
+        og.images = [ogImage];
+    if (Object.keys(og).length > 0)
+        out.openGraph = og;
+    return out;
+}

package/dist/next/page-renderer.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentType, ReactElement } from "react";
+import type { Metadata } from "next";
+import type { CollectionSchema } from "../collections.ts";
+import type { EntryStore } from "../entry-store.ts";
+import type { Descriptor } from "../fields.ts";
+import { type PairedPage } from "../render.tsx";
+import type { PageStore } from "../store.ts";
+/** A registered section, as both the renderer and the ref resolver need it. */
+type SectionEntry = ComponentType<any> & {
+    schema: {
+        name: string;
+        fields: Record<string, Descriptor>;
+    };
+};
+export type PageRendererOptions = {
+    /** Lazy so `next build` never needs env vars at import time. */
+    stores: () => {
+        pages: PageStore;
+        entries: EntryStore;
+    };
+    sections: SectionEntry[];
+    collections: CollectionSchema<any>[];
+    /** Cache tag per slug; must match what publish revalidates. */
+    tag?: (slug: string) => string;
+};
+export type RenderOptions = {
+    slug?: string;
+    searchParams?: Promise<Record<string, string | string[] | undefined>>;
+};
+export declare function createPageRenderer(options: PageRendererOptions): {
+    renderSmoodlyPage<Z extends Record<string, unknown>>(Page: PairedPage<Z>, opts?: RenderOptions): Promise<ReactElement>;
+    smoodlyMetadata<Z extends Record<string, unknown>>(Page: PairedPage<Z>, opts?: {
+        slug?: string;
+    }): Promise<Metadata>;
+};
+export {};

package/dist/next/page-renderer.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { unstable_cache } from "next/cache";
+import { draftMode } from "next/headers";
+import { notFound } from "next/navigation";
+import { connection } from "next/server";
+import { EditorBridge } from "../admin/next/bridge.js";
+import { renderPage } from "../render.js";
+import { resolveTree } from "../resolve.js";
+import { metadataFrom, pageSlugFor } from "./meta.js";
+export function createPageRenderer(options) {
+    const tag = options.tag ?? ((slug) => `page:${slug}`);
+    const resolved = (tree, o) => resolveTree(tree, {
+        sections: options.sections,
+        collections: options.collections,
+        fetch: (collection, ids) => options.stores().entries.getMany(collection, ids, o),
+    });
+    // The cached unit is the RESOLVED tree: entry data is frozen with the
+    // page, so an entry edit only appears once the revalidation fan-out
+    // fires revalidateTag("page:<slug>").
+    const cachedPublished = (slug) => unstable_cache(async () => {
+        const { pages } = options.stores();
+        const record = await pages.getPage(slug);
+        const tree = record?.publishedVersionId ? await pages.getPublishedTree(slug) : null;
+        return record && tree
+            ? { template: record.template, tree: await resolved(tree, { status: "published" }) }
+            : null;
+    }, 
+    // Prefixed so it never collides with the surviving catch-all's own
+    // ["resolved-page", slug] cache in the same app.
+    ["smoodly-resolved-page", slug], { tags: [tag(slug)] })();
+    async function load(slug, draft) {
+        if (!draft)
+            return cachedPublished(slug);
+        const { pages } = options.stores();
+        const record = await pages.getPage(slug);
+        const tree = record ? await pages.getDraftTree(slug) : null;
+        return record && tree ? { template: record.template, tree: await resolved(tree) } : null;
+    }
+    /** A record that exists but belongs to another registration is a 404
+     * for THIS route — otherwise the open [slug] route would render a fixed
+     * page's record through its own view at a duplicate URL. */
+    function forRegistration(loaded, name) {
+        return loaded && loaded.template === name ? loaded.tree : null;
+    }
+    return {
+        async renderSmoodlyPage(Page, opts) {
+            // A CMS route is request-rendered by construction: without this a
+            // fixed-slug route file has nothing dynamic in it, so `next build`
+            // would prerender it against the database (DESIGN.md §3, OQ #19).
+            await connection();
+            const slug = pageSlugFor(Page.schema, opts?.slug);
+            const { isEnabled: draft } = await draftMode();
+            const tree = forRegistration(await load(slug, draft), Page.schema.name);
+            if (!tree)
+                notFound();
+            const editor = draft && (await opts?.searchParams)?.["smoodly-editor"] === "1";
+            return (_jsxs(_Fragment, { children: [editor ? _jsx(EditorBridge, {}) : null, renderPage(Page, tree, { sections: options.sections }, { editor })] }));
+        },
+        async smoodlyMetadata(Page, opts) {
+            // generateMetadata runs alongside the page render, so it must gate
+            // on the request too or a build could still reach the database here.
+            await connection();
+            const slug = pageSlugFor(Page.schema, opts?.slug);
+            const { isEnabled: draft } = await draftMode();
+            const tree = forRegistration(await load(slug, draft), Page.schema.name);
+            return metadataFrom(tree?.meta);
+        },
+    };
+}

package/dist/page.d.ts

@@ -0,0 +1,22 @@
+import type { ZonePolicy } from "./zones.ts";
+export type PageSchema<Zones extends Record<string, unknown> = Record<string, unknown>> = {
+    kind: "page";
+    name: string;
+    title: string;
+    /** Fixed: this registration owns exactly ONE page record, at this slug,
+     * served by one route file. Absent = open: editors create many.
+     * The route file serving "/" must declare the config's `homePageSlug`
+     * (default "home") — that is how the admin maps its record to "/". */
+    slug?: string;
+    zones: Record<keyof Zones & string, ZonePolicy>;
+    meta: Record<string, unknown>;
+    /** phantom: zone names for Props inference */
+    readonly __zones?: Zones;
+};
+export declare function pageSchema<Zones extends Record<string, object>>(input: {
+    name: string;
+    title: string;
+    slug?: string;
+    zones: Zones;
+    meta?: Record<string, unknown>;
+}): PageSchema<Zones>;

package/dist/page.js

@@ -0,0 +1,35 @@
+/** Policies arrive as z.* results (possibly carrying builder methods) — store plain data only. */
+function normalizePolicy(p) {
+    switch (p.kind) {
+        case "sections": {
+            const out = { kind: "sections", allow: p.allow };
+            if (typeof p.max === "number")
+                out.max = p.max;
+            return out;
+        }
+        case "freeform":
+            return { kind: "freeform", allow: p.allow, rows: p.rows };
+        case "locked":
+            return { kind: "locked", component: p.component };
+        default:
+            throw new Error(`smoodly: unknown zone policy kind "${String(p.kind)}".`);
+    }
+}
+export function pageSchema(input) {
+    if (!input?.name)
+        throw new Error("smoodly: a page requires a name.");
+    // A fixed slug is decided by `slug !== undefined` at every other hop, but
+    // the renderer's path lookup is truthiness-based: an empty string would read
+    // as fixed to the admin and blow up in the route. Reject it at construction.
+    if (input.slug !== undefined && (typeof input.slug !== "string" || input.slug.trim() === "")) {
+        throw new Error(`smoodly: page "${input.name}" declares an invalid slug — a fixed slug must be a non-empty string.`);
+    }
+    return {
+        kind: "page",
+        name: input.name,
+        title: input.title,
+        ...(input.slug !== undefined ? { slug: input.slug } : {}),
+        zones: Object.fromEntries(Object.entries(input.zones).map(([k, p]) => [k, normalizePolicy(p)])),
+        meta: input.meta ?? {},
+    };
+}

package/dist/pairing.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentType, ReactElement } from "react";
+import type { BuilderMap, ElementSchema, NamespaceValues, SectionSchema } from "./schema.ts";
+import type { ZoneContent } from "./render.tsx";
+/** What the view receives. A page view gets its zones; a section/element
+ * view gets field values flat and styles complete (defaults filled).
+ * The page branch keys on `kind` — an optional-only check would match
+ * section schemas too, since a type lacking `__zones` still extends
+ * `{ __zones?: X }`. */
+export type Props<S> = S extends {
+    kind: "page";
+    __zones?: infer Z extends Record<string, unknown>;
+} ? {
+    zones: Record<keyof Z & string, ZoneContent>;
+} : S extends {
+    __f?: infer F extends BuilderMap;
+    __s?: infer St extends BuilderMap;
+} ? NamespaceValues<F> & {
+    styles: NamespaceValues<St>;
+} : never;
+/** What hard-coded JSX may pass: fields flat, styles optional and partial. */
+type ExternalProps<F extends BuilderMap, St extends BuilderMap> = NamespaceValues<F> & {
+    styles?: Partial<NamespaceValues<St>>;
+};
+export type PairedComponent<Schema, F extends BuilderMap, St extends BuilderMap> = ((props: ExternalProps<F, St>) => ReactElement) & {
+    schema: Schema;
+};
+export declare function section<F extends BuilderMap, St extends BuilderMap>(schema: SectionSchema<F, St>, View: ComponentType<NamespaceValues<F> & {
+    styles: NamespaceValues<St>;
+}>): PairedComponent<SectionSchema<F, St>, F, St>;
+export declare function element<F extends BuilderMap, St extends BuilderMap>(schema: ElementSchema<F, St>, View: ComponentType<NamespaceValues<F> & {
+    styles: NamespaceValues<St>;
+}>): PairedComponent<ElementSchema<F, St>, F, St>;
+export {};

package/dist/pairing.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+function styleDefaultsOf(styles) {
+    const out = {};
+    for (const [key, d] of Object.entries(styles)) {
+        if (d.default !== undefined)
+            out[key] = d.default;
+    }
+    return out;
+}
+function pair(schema, View) {
+    const defaults = styleDefaultsOf(schema.styles);
+    const Component = (props) => {
+        const { styles: styleOverrides, ...fields } = props ?? {};
+        const styles = { ...defaults, ...styleOverrides };
+        const V = View;
+        return _jsx(V, { ...fields, styles: styles });
+    };
+    Component.schema = schema;
+    return Component;
+}
+export function section(schema, View) {
+    return pair(schema, View);
+}
+export function element(schema, View) {
+    return pair(schema, View);
+}

package/dist/ref-index.d.ts

@@ -0,0 +1,19 @@
+import type { RefEdge } from "./refs.ts";
+export type RefSource = {
+    sourceKind: string;
+    sourceId: string;
+};
+export declare class MemoryRefIndex {
+    private rows;
+    /** Replace a source's outgoing edges wholesale (what every save does). */
+    rewrite(source: RefSource, edges: RefEdge[]): void;
+    remove({ sourceKind, sourceId }: RefSource): void;
+    /** The reverse question: who points at this target? */
+    to(targetCollection: string, targetId: string): {
+        sourceKind: string;
+        sourceId: string;
+        sourceField: string;
+    }[];
+    /** Reverse lookup by id alone (ids are globally unique) — the fan-out walk. */
+    incoming(targetId: string): RefSource[];
+}

package/dist/refs.d.ts

@@ -0,0 +1,20 @@
+import type { Descriptor } from "./fields.ts";
+import type { CollectionSchema } from "./collections.ts";
+import type { PageTree } from "./render.tsx";
+export type RefEdge = {
+    field: string;
+    targetCollection: string;
+    targetId: string;
+};
+export declare function collectEntryRefs(fields: Record<string, unknown>, schema: CollectionSchema<any>): RefEdge[];
+/** A section schema, or anything carrying one (a paired component). */
+export type SectionLike = {
+    name: string;
+    fields: Record<string, Descriptor>;
+} | {
+    schema: {
+        name: string;
+        fields: Record<string, Descriptor>;
+    };
+};
+export declare function collectTreeRefs(tree: PageTree, sections: SectionLike[]): RefEdge[];

package/dist/refs.js

@@ -0,0 +1,49 @@
+// The refs index feeders (DESIGN.md §3): walk a document against its
+// schema and list every outgoing reference edge. Colocated schemas mean
+// ref fields are always known, so the index is derived, rebuildable,
+// and never the source of truth. Stores rewrite a source's edges on
+// every save; `refs` answers only the REVERSE question (who depends on
+// this?) — forward resolution stays resolveTree's job.
+function targetOf(d) {
+    const t = d.target?.();
+    if (!t?.name)
+        throw new Error("smoodly: ref descriptor has no resolvable target.");
+    return t.name;
+}
+function collectFrom(values, descriptors, out) {
+    for (const [field, d] of Object.entries(descriptors)) {
+        const value = values[field];
+        if (value == null)
+            continue;
+        if (d.type === "ref" && typeof value === "string") {
+            out.push({ field, targetCollection: targetOf(d), targetId: value });
+        }
+        else if (d.type === "refList" && Array.isArray(value)) {
+            for (const id of value) {
+                if (typeof id === "string")
+                    out.push({ field, targetCollection: targetOf(d), targetId: id });
+            }
+        }
+    }
+}
+export function collectEntryRefs(fields, schema) {
+    const out = [];
+    collectFrom(fields, schema.fields, out);
+    return out;
+}
+export function collectTreeRefs(tree, sections) {
+    const byName = new Map(sections.map((s) => {
+        const schema = "schema" in s ? s.schema : s;
+        return [schema.name, schema];
+    }));
+    const out = [];
+    for (const nodes of Object.values(tree.zones ?? {})) {
+        for (const node of nodes) {
+            const schema = byName.get(node.type);
+            if (!schema)
+                continue; // fail-soft, same as renderPage
+            collectFrom(node.fields, schema.fields, out);
+        }
+    }
+    return out;
+}

package/dist/render.d.ts

@@ -0,0 +1,48 @@
+import type { ComponentType, ReactElement } from "react";
+import type { PageSchema } from "./page.ts";
+export type TreeNode = {
+    id: string;
+    type: string;
+    fields: Record<string, unknown>;
+    styles?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+};
+/** `meta` is the page's own metadata (SEO title, description, og image).
+ * It rides inside the tree deliberately: trees are already JSONB in
+ * page_versions, so this needs no DDL change, and page meta becomes
+ * versioned with content — draft SEO edits stay unpublished, and publish
+ * moves content and meta together. */
+export type PageTree = {
+    zones: Record<string, TreeNode[]>;
+    meta?: Record<string, unknown>;
+};
+type AnyPaired = ComponentType<any> & {
+    schema: {
+        name: string;
+    };
+};
+export type ZoneContent = {
+    readonly name: string;
+    readonly nodes: TreeNode[];
+    readonly components: ReadonlyMap<string, AnyPaired>;
+    readonly editor: boolean;
+};
+export declare function Zone({ of: content }: {
+    of: ZoneContent;
+}): import("react").JSX.Element | null;
+export type PairedPage<Zones extends Record<string, unknown>> = ((props: {
+    zones: Record<keyof Zones & string, ZoneContent>;
+}) => ReactElement) & {
+    schema: PageSchema<Zones>;
+};
+export declare function page<Zones extends Record<string, unknown>>(schema: PageSchema<Zones>, View: ComponentType<{
+    zones: Record<keyof Zones & string, ZoneContent>;
+}>): PairedPage<Zones>;
+export type Registry = {
+    sections?: AnyPaired[];
+    elements?: AnyPaired[];
+};
+export declare function renderPage<Zones extends Record<string, unknown>>(Page: PairedPage<Zones>, tree: PageTree, registry: Registry, options?: {
+    editor?: boolean;
+}): ReactElement;
+export {};

package/dist/render.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+export function Zone({ of: content }) {
+    // A malformed tree (bad data, a client that skipped isPageTree) must not
+    // crash the render — treat a non-array nodes as empty rather than throw.
+    const nodes = Array.isArray(content?.nodes) ? content.nodes : [];
+    if (!nodes.length) {
+        // In editor mode an empty zone still needs a measurable box for the
+        // overlay's "+ add" affordance; in production it renders nothing.
+        return content?.editor ? (_jsx("div", { "data-smoodly-zone": content.name, "data-smoodly-empty": "", style: { minHeight: 48 } })) : null;
+    }
+    return (_jsx(_Fragment, { children: nodes.map((node) => {
+            const Component = content.components.get(node.type);
+            if (!Component) {
+                console.warn(`smoodly: no registered component for node type "${node.type}" — skipping.`);
+                return null;
+            }
+            const styles = content.editor
+                ? { ...(node.styles ?? {}), __smoodlyNode: node.id }
+                : (node.styles ?? {});
+            return _jsx(Component, { ...node.fields, styles: styles }, node.id);
+        }) }));
+}
+export function page(schema, View) {
+    const Component = ((props) => {
+        const V = View;
+        return _jsx(V, { zones: props.zones });
+    });
+    Component.schema = schema;
+    return Component;
+}
+export function renderPage(Page, tree, registry, options) {
+    const components = new Map();
+    for (const c of [...(registry.sections ?? []), ...(registry.elements ?? [])]) {
+        components.set(c.schema.name, c);
+    }
+    const zones = Object.fromEntries(Object.keys(Page.schema.zones).map((zone) => [
+        zone,
+        { name: zone, nodes: tree.zones?.[zone] ?? [], components, editor: options?.editor ?? false },
+    ]));
+    return _jsx(Page, { zones: zones });
+}