smoodly 0.0.1

package/dist/store.d.ts

@@ -0,0 +1,73 @@
+import type { PageTree } from "./render.tsx";
+import type { EntryStore } from "./entry-store.ts";
+import { type RefEdge, type SectionLike } from "./refs.ts";
+import type { MemoryRefIndex } from "./ref-index.ts";
+export type PageRecord = {
+    id: string;
+    slug: string;
+    template: string;
+    status: "draft" | "published";
+    draftVersionId: string;
+    publishedVersionId: string | null;
+};
+export type PageVersion = {
+    id: string;
+    pageId: string;
+    tree: PageTree;
+    createdAt: number;
+};
+export interface PageStore {
+    createPage(input: {
+        slug: string;
+        template: string;
+    }): Promise<PageRecord>;
+    getPage(slug: string): Promise<PageRecord | null>;
+    /** By-id lookup — the fan-out walk holds page ids, not slugs. */
+    getPageById(id: string): Promise<PageRecord | null>;
+    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
+    publish(slug: string): Promise<PageRecord>;
+    getDraftTree(slug: string): Promise<PageTree | null>;
+    getPublishedTree(slug: string): Promise<PageTree | null>;
+    listVersions(slug: string): Promise<PageVersion[]>;
+    /** All pages, slug-ascending — the admin's pages list. */
+    listPages(): Promise<PageRecord[]>;
+    /** Removes the page, its versions and its refs rows. Missing slug: no-op. */
+    deletePage(slug: string): Promise<void>;
+}
+/** What a PageStore needs beyond its tables to maintain the refs index
+ * and gate publishes. All optional: without `sections` no refs are
+ * written; without `entries` publishing is not integrity-checked. */
+export type PageStoreOptions = {
+    sections?: SectionLike[];
+    entries?: EntryStore;
+};
+/** A page's refs rows cover BOTH live trees — edges(draft) ∪
+ * edges(published) — so an entry stays delete-guarded while either tree
+ * shows it. Callers dedupe on write (the SQL PK does it for real). */
+export declare function pageRefEdges(draft: PageTree, published: PageTree | null, sections: SectionLike[]): RefEdge[];
+/** The publish-integrity gate (DESIGN.md §3): a page must not go live
+ * showing entries the published site can't resolve — every referenced
+ * entry must exist and be published. Throws naming the offenders. */
+export declare function assertPublishable(slug: string, tree: PageTree, sections: SectionLike[], entries: EntryStore): Promise<void>;
+export declare class MemoryPageStore implements PageStore {
+    private options;
+    private pages;
+    private versions;
+    constructor(options?: PageStoreOptions & {
+        refs?: MemoryRefIndex;
+    });
+    private writeRefs;
+    createPage({ slug, template }: {
+        slug: string;
+        template: string;
+    }): Promise<PageRecord>;
+    getPage(slug: string): Promise<PageRecord | null>;
+    getPageById(id: string): Promise<PageRecord | null>;
+    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
+    publish(slug: string): Promise<PageRecord>;
+    getDraftTree(slug: string): Promise<PageTree | null>;
+    getPublishedTree(slug: string): Promise<PageTree | null>;
+    listVersions(slug: string): Promise<PageVersion[]>;
+    listPages(): Promise<PageRecord[]>;
+    deletePage(slug: string): Promise<void>;
+}

package/dist/store.js

@@ -0,0 +1,145 @@
+// The page persistence contract. Writes always go through this API —
+// never raw table access — so validation, versioning and publish hooks
+// can't be bypassed (DESIGN.md §1). MemoryPageStore is the reference
+// implementation and the contract-test subject; the Supabase adapter
+// implements the same interface over pages/page_versions.
+import { collectTreeRefs } from "./refs.js";
+/** A page's refs rows cover BOTH live trees — edges(draft) ∪
+ * edges(published) — so an entry stays delete-guarded while either tree
+ * shows it. Callers dedupe on write (the SQL PK does it for real). */
+export function pageRefEdges(draft, published, sections) {
+    const edges = collectTreeRefs(draft, sections);
+    if (published)
+        edges.push(...collectTreeRefs(published, sections));
+    return edges;
+}
+/** The publish-integrity gate (DESIGN.md §3): a page must not go live
+ * showing entries the published site can't resolve — every referenced
+ * entry must exist and be published. Throws naming the offenders. */
+export async function assertPublishable(slug, tree, sections, entries) {
+    const targets = new Map();
+    for (const edge of collectTreeRefs(tree, sections)) {
+        if (!targets.has(edge.targetId))
+            targets.set(edge.targetId, { collection: edge.targetCollection, field: edge.field });
+    }
+    const offenders = [];
+    for (const [id, { collection, field }] of targets) {
+        const entry = await entries.get(collection, id);
+        if (entry?.status !== "published")
+            offenders.push(`${collection}/${id} (${field}${entry ? "" : ", missing"})`);
+    }
+    if (offenders.length > 0) {
+        throw new Error(`smoodly: cannot publish "${slug}" — it references entries that are not published: ${offenders.join(", ")}.`);
+    }
+}
+let counter = 0;
+const uid = () => `id-${++counter}-${Date.now().toString(36)}`;
+export class MemoryPageStore {
+    constructor(options = {}) {
+        this.options = options;
+        this.pages = new Map();
+        this.versions = new Map();
+    }
+    writeRefs(pageId, draft, published) {
+        const { sections, refs } = this.options;
+        if (!sections || !refs)
+            return;
+        refs.rewrite({ sourceKind: "page", sourceId: pageId }, pageRefEdges(draft, published, sections));
+    }
+    async createPage({ slug, template }) {
+        if (this.pages.has(slug))
+            throw new Error(`smoodly: a page with slug "${slug}" already exists.`);
+        const pageId = uid();
+        const version = { id: uid(), pageId, tree: { zones: {} }, createdAt: Date.now() };
+        this.versions.set(version.id, version);
+        const page = {
+            id: pageId,
+            slug,
+            template,
+            status: "draft",
+            draftVersionId: version.id,
+            publishedVersionId: null,
+        };
+        this.pages.set(slug, page);
+        return { ...page };
+    }
+    async getPage(slug) {
+        const page = this.pages.get(slug);
+        return page ? { ...page } : null;
+    }
+    async getPageById(id) {
+        for (const page of this.pages.values())
+            if (page.id === id)
+                return { ...page };
+        return null;
+    }
+    async saveDraft(slug, tree) {
+        const page = this.pages.get(slug);
+        if (!page)
+            throw new Error(`smoodly: no page with slug "${slug}".`);
+        const version = {
+            id: uid(),
+            pageId: page.id,
+            tree: structuredClone(tree),
+            createdAt: Date.now(),
+        };
+        this.versions.set(version.id, version);
+        page.draftVersionId = version.id;
+        const published = page.publishedVersionId
+            ? (this.versions.get(page.publishedVersionId)?.tree ?? null)
+            : null;
+        this.writeRefs(page.id, version.tree, published);
+        return { ...version };
+    }
+    async publish(slug) {
+        const page = this.pages.get(slug);
+        if (!page)
+            throw new Error(`smoodly: no page with slug "${slug}".`);
+        const { sections, entries } = this.options;
+        if (sections && entries) {
+            const draft = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
+            await assertPublishable(slug, draft, sections, entries);
+        }
+        page.publishedVersionId = page.draftVersionId;
+        page.status = "published";
+        const tree = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
+        this.writeRefs(page.id, tree, null); // draft IS published now — one tree
+        return { ...page };
+    }
+    async getDraftTree(slug) {
+        const page = this.pages.get(slug);
+        if (!page)
+            return null;
+        return structuredClone(this.versions.get(page.draftVersionId)?.tree ?? null);
+    }
+    async getPublishedTree(slug) {
+        const page = this.pages.get(slug);
+        if (!page?.publishedVersionId)
+            return null;
+        return structuredClone(this.versions.get(page.publishedVersionId)?.tree ?? null);
+    }
+    async listVersions(slug) {
+        const page = this.pages.get(slug);
+        if (!page)
+            return [];
+        return [...this.versions.values()]
+            .filter((v) => v.pageId === page.id)
+            .sort((a, b) => b.createdAt - a.createdAt || b.id.localeCompare(a.id))
+            .map((v) => ({ ...v, tree: structuredClone(v.tree) }));
+    }
+    async listPages() {
+        return [...this.pages.values()]
+            .sort((a, b) => a.slug.localeCompare(b.slug))
+            .map((p) => ({ ...p }));
+    }
+    async deletePage(slug) {
+        const page = this.pages.get(slug);
+        if (!page)
+            return;
+        for (const [id, v] of this.versions)
+            if (v.pageId === page.id)
+                this.versions.delete(id);
+        this.options.refs?.remove({ sourceKind: "page", sourceId: page.id });
+        this.pages.delete(slug);
+    }
+}

package/dist/supabase-entry-store.d.ts

@@ -0,0 +1,26 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import type { CollectionSchema } from "./collections.ts";
+import type { EntryRecord, EntryStore, EntryUsage, ListOptions } from "./entry-store.ts";
+export declare class SupabaseEntryStore implements EntryStore {
+    private db;
+    private collections;
+    constructor(db: SupabaseClient, collections: CollectionSchema<any>[]);
+    private fail;
+    private writeRefs;
+    create(collection: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    get(collection: string, id: string): Promise<EntryRecord | null>;
+    list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
+    getMany(collection: string, ids: string[], options?: {
+        status?: "published";
+    }): Promise<Record<string, Record<string, unknown>>>;
+    private patch;
+    update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    delete(collection: string, id: string): Promise<void>;
+    reorder(collection: string, orderedIds: string[]): Promise<void>;
+    incoming(targetId: string): Promise<{
+        sourceKind: string;
+        sourceId: string;
+    }[]>;
+    referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
+}

package/dist/supabase-entry-store.js

@@ -0,0 +1,191 @@
+// The Supabase adapter for the EntryStore contract, over entries + refs.
+// Service-role client, server-side only (writes bypass RLS by design —
+// DESIGN.md §1). Reorder calls the smoodly_reorder SQL function: one
+// statement for the whole collection, updated_at untouched.
+import { schemaOf } from "./entry-store.js";
+import { collectEntryRefs } from "./refs.js";
+// entries.id is a Postgres uuid column: filtering on a non-UUID string
+// throws invalid_text_representation. A non-UUID id can't exist in the
+// table, so treat it the same as a missing one — getMany silently omits
+// it, patch raises the contract's "no entry" error — rather than letting
+// the cast error leak through.
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function toRecord(row) {
+    return {
+        id: row.id,
+        collection: row.collection,
+        fields: row.fields,
+        status: row.status,
+        sort: row.sort,
+        createdAt: Date.parse(row.created_at),
+        updatedAt: Date.parse(row.updated_at),
+    };
+}
+export class SupabaseEntryStore {
+    constructor(db, collections) {
+        this.db = db;
+        this.collections = collections;
+    }
+    fail(message) {
+        throw new Error(`smoodly: ${message}`);
+    }
+    async writeRefs(collection, id, fields) {
+        const schema = schemaOf(this.collections, collection);
+        const deleted = await this.db
+            .from("refs")
+            .delete()
+            .eq("source_kind", "entry")
+            .eq("source_id", id);
+        if (deleted.error)
+            this.fail(deleted.error.message);
+        // dedupe: the refs PK is (source_kind, source_id, source_field, target_id)
+        const rows = new Map();
+        for (const edge of collectEntryRefs(fields, schema)) {
+            rows.set(`${edge.field}\x00${edge.targetId}`, {
+                source_kind: "entry",
+                source_id: id,
+                source_field: edge.field,
+                target_collection: edge.targetCollection,
+                target_id: edge.targetId,
+            });
+        }
+        if (rows.size > 0) {
+            const inserted = await this.db.from("refs").insert([...rows.values()]);
+            if (inserted.error)
+                this.fail(inserted.error.message);
+        }
+    }
+    async create(collection, fields) {
+        schemaOf(this.collections, collection);
+        const res = await this.db.from("entries").insert({ collection, fields }).select("*").single();
+        if (res.error)
+            this.fail(res.error.message);
+        const row = res.data;
+        await this.writeRefs(collection, row.id, fields);
+        return toRecord(row);
+    }
+    async get(collection, id) {
+        const res = await this.db
+            .from("entries")
+            .select("*")
+            .eq("collection", collection)
+            .eq("id", id)
+            .maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data ? toRecord(res.data) : null;
+    }
+    async list(collection, options) {
+        schemaOf(this.collections, collection);
+        let query = this.db.from("entries").select("*").eq("collection", collection);
+        if (options?.status)
+            query = query.eq("status", options.status);
+        const order = options?.order ?? "created";
+        if (order === "updated")
+            query = query.order("updated_at", { ascending: false });
+        else if (order === "manual")
+            query = query
+                .order("sort", { ascending: true, nullsFirst: false })
+                .order("created_at", { ascending: true });
+        else
+            query = query.order("created_at", { ascending: true }).order("id", { ascending: true });
+        const res = await query;
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toRecord);
+    }
+    async getMany(collection, ids, options) {
+        schemaOf(this.collections, collection);
+        const uuidIds = ids.filter((id) => UUID_RE.test(id));
+        if (uuidIds.length === 0)
+            return {};
+        let query = this.db
+            .from("entries")
+            .select("id, fields")
+            .eq("collection", collection)
+            .in("id", uuidIds);
+        if (options?.status)
+            query = query.eq("status", options.status);
+        const res = await query;
+        if (res.error)
+            this.fail(res.error.message);
+        const out = {};
+        for (const row of res.data) {
+            out[row.id] = row.fields;
+        }
+        return out;
+    }
+    async patch(collection, id, patch) {
+        if (!UUID_RE.test(id))
+            this.fail(`no entry "${id}" in "${collection}".`);
+        const res = await this.db
+            .from("entries")
+            .update({ ...patch, updated_at: new Date().toISOString() })
+            .eq("collection", collection)
+            .eq("id", id)
+            .select("*")
+            .maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        if (!res.data)
+            this.fail(`no entry "${id}" in "${collection}".`);
+        return toRecord(res.data);
+    }
+    async update(collection, id, fields) {
+        const record = await this.patch(collection, id, { fields });
+        await this.writeRefs(collection, id, fields);
+        return record;
+    }
+    async setStatus(collection, id, status) {
+        return this.patch(collection, id, { status });
+    }
+    async delete(collection, id) {
+        const usage = await this.referencesTo(collection, id);
+        if (usage.length > 0) {
+            this.fail(`"${collection}/${id}" is referenced by ${usage.length} document(s) — remove those references first.`);
+        }
+        const refs = await this.db.from("refs").delete().eq("source_kind", "entry").eq("source_id", id);
+        if (refs.error)
+            this.fail(refs.error.message);
+        const res = await this.db.from("entries").delete().eq("collection", collection).eq("id", id);
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    async reorder(collection, orderedIds) {
+        schemaOf(this.collections, collection);
+        const res = await this.db.rpc("smoodly_reorder", {
+            p_collection: collection,
+            p_ids: orderedIds,
+        });
+        if (res.error)
+            this.fail(res.error.message);
+    }
+    async incoming(targetId) {
+        const res = await this.db
+            .from("refs")
+            .select("source_kind, source_id")
+            .eq("target_id", targetId);
+        if (res.error)
+            this.fail(res.error.message);
+        const seen = new Set(); // one row per source (multiple fields collapse)
+        const out = [];
+        for (const r of res.data) {
+            const key = `${r.source_kind} ${r.source_id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ sourceKind: r.source_kind, sourceId: r.source_id });
+        }
+        return out;
+    }
+    async referencesTo(collection, id) {
+        const res = await this.db
+            .from("refs")
+            .select("source_kind, source_id, source_field")
+            .eq("target_collection", collection)
+            .eq("target_id", id);
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map((r) => ({ sourceKind: r.source_kind, sourceId: r.source_id, sourceField: r.source_field }));
+    }
+}

package/dist/supabase-store.d.ts

@@ -0,0 +1,26 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
+import type { PageTree } from "./render.tsx";
+export declare class SupabasePageStore implements PageStore {
+    private db;
+    private options;
+    constructor(db: SupabaseClient, options?: PageStoreOptions);
+    private writeRefs;
+    private pageRow;
+    private insertVersion;
+    private setPointers;
+    createPage({ slug, template }: {
+        slug: string;
+        template: string;
+    }): Promise<PageRecord>;
+    getPage(slug: string): Promise<PageRecord | null>;
+    getPageById(id: string): Promise<PageRecord | null>;
+    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
+    publish(slug: string): Promise<PageRecord>;
+    private versionTree;
+    getDraftTree(slug: string): Promise<PageTree | null>;
+    getPublishedTree(slug: string): Promise<PageTree | null>;
+    listVersions(slug: string): Promise<PageVersion[]>;
+    listPages(): Promise<PageRecord[]>;
+    deletePage(slug: string): Promise<void>;
+}

package/dist/supabase-store.js

@@ -0,0 +1,180 @@
+// The Supabase adapter for the PageStore contract, over pages +
+// page_versions. Server-side only, service-role client — writes bypass
+// RLS by design because they flow through Smoodly's API (DESIGN.md §1).
+// No FK links pages' version pointers to page_versions (they'd be
+// circular), so tree reads are two indexed lookups, not embeds.
+import { assertPublishable, pageRefEdges } from "./store.js";
+const UNIQUE_VIOLATION = "23505";
+function toRecord(row) {
+    return {
+        id: row.id,
+        slug: row.slug,
+        template: row.template,
+        status: row.status,
+        draftVersionId: row.draft_version_id,
+        publishedVersionId: row.published_version_id,
+    };
+}
+function toVersion(row) {
+    return { id: row.id, pageId: row.page_id, tree: row.tree, createdAt: Date.parse(row.created_at) };
+}
+export class SupabasePageStore {
+    constructor(db, options = {}) {
+        this.db = db;
+        this.options = options;
+    }
+    async writeRefs(pageId, edges) {
+        const deleted = await this.db
+            .from("refs")
+            .delete()
+            .eq("source_kind", "page")
+            .eq("source_id", pageId);
+        if (deleted.error)
+            throw new Error(`smoodly: ${deleted.error.message}`);
+        // dedupe: the refs PK is (source_kind, source_id, source_field, target_id)
+        const rows = new Map();
+        for (const edge of edges) {
+            rows.set(`${edge.field} ${edge.targetId}`, {
+                source_kind: "page",
+                source_id: pageId,
+                source_field: edge.field,
+                target_collection: edge.targetCollection,
+                target_id: edge.targetId,
+            });
+        }
+        if (rows.size > 0) {
+            const inserted = await this.db.from("refs").insert([...rows.values()]);
+            if (inserted.error)
+                throw new Error(`smoodly: ${inserted.error.message}`);
+        }
+    }
+    async pageRow(slug) {
+        const res = await this.db.from("pages").select("*").eq("slug", slug).maybeSingle();
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data ?? null;
+    }
+    async insertVersion(pageId, tree) {
+        const res = await this.db
+            .from("page_versions")
+            .insert({ page_id: pageId, tree })
+            .select("*")
+            .single();
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data;
+    }
+    async setPointers(id, patch) {
+        const res = await this.db
+            .from("pages")
+            .update({ ...patch, updated_at: new Date().toISOString() })
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data;
+    }
+    async createPage({ slug, template }) {
+        const inserted = await this.db.from("pages").insert({ slug, template }).select("*").single();
+        if (inserted.error) {
+            if (inserted.error.code === UNIQUE_VIOLATION)
+                throw new Error(`smoodly: a page with slug "${slug}" already exists.`);
+            throw new Error(`smoodly: ${inserted.error.message}`);
+        }
+        const page = inserted.data;
+        const version = await this.insertVersion(page.id, { zones: {} });
+        return toRecord(await this.setPointers(page.id, { draft_version_id: version.id }));
+    }
+    async getPage(slug) {
+        const row = await this.pageRow(slug);
+        return row ? toRecord(row) : null;
+    }
+    async getPageById(id) {
+        const res = await this.db.from("pages").select("*").eq("id", id).maybeSingle();
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data ? toRecord(res.data) : null;
+    }
+    async saveDraft(slug, tree) {
+        const page = await this.pageRow(slug);
+        if (!page)
+            throw new Error(`smoodly: no page with slug "${slug}".`);
+        const version = await this.insertVersion(page.id, tree);
+        await this.setPointers(page.id, { draft_version_id: version.id });
+        if (this.options.sections) {
+            const published = await this.versionTree(page.published_version_id);
+            await this.writeRefs(page.id, pageRefEdges(tree, published, this.options.sections));
+        }
+        return toVersion(version);
+    }
+    async publish(slug) {
+        const page = await this.pageRow(slug);
+        if (!page)
+            throw new Error(`smoodly: no page with slug "${slug}".`);
+        const { sections, entries } = this.options;
+        const draft = (await this.versionTree(page.draft_version_id)) ?? { zones: {} };
+        if (sections && entries)
+            await assertPublishable(slug, draft, sections, entries);
+        const record = toRecord(await this.setPointers(page.id, {
+            published_version_id: page.draft_version_id,
+            status: "published",
+        }));
+        // draft IS published now — one tree
+        if (sections)
+            await this.writeRefs(page.id, pageRefEdges(draft, null, sections));
+        return record;
+    }
+    async versionTree(versionId) {
+        if (!versionId)
+            return null;
+        const res = await this.db.from("page_versions").select("tree").eq("id", versionId).maybeSingle();
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data?.tree ?? null;
+    }
+    async getDraftTree(slug) {
+        const page = await this.pageRow(slug);
+        return page ? this.versionTree(page.draft_version_id) : null;
+    }
+    async getPublishedTree(slug) {
+        const page = await this.pageRow(slug);
+        return page ? this.versionTree(page.published_version_id) : null;
+    }
+    async listVersions(slug) {
+        const page = await this.pageRow(slug);
+        if (!page)
+            return [];
+        const res = await this.db
+            .from("page_versions")
+            .select("*")
+            .eq("page_id", page.id)
+            .order("created_at", { ascending: false })
+            .order("id", { ascending: false });
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data.map(toVersion);
+    }
+    async listPages() {
+        const res = await this.db.from("pages").select("*").order("slug", { ascending: true });
+        if (res.error)
+            throw new Error(`smoodly: ${res.error.message}`);
+        return res.data.map(toRecord);
+    }
+    async deletePage(slug) {
+        const page = await this.pageRow(slug);
+        if (!page)
+            return;
+        for (const [table, col, val] of [
+            ["refs", "source_id", page.id],
+            ["page_versions", "page_id", page.id],
+            ["pages", "id", page.id],
+        ]) {
+            const res = table === "refs"
+                ? await this.db.from(table).delete().eq("source_kind", "page").eq(col, val)
+                : await this.db.from(table).delete().eq(col, val);
+            if (res.error)
+                throw new Error(`smoodly: ${res.error.message}`);
+        }
+    }
+}

package/dist/zones.d.ts

@@ -0,0 +1,31 @@
+type WithSchema = {
+    schema: {
+        name: string;
+    };
+};
+export type ZonePolicy = {
+    kind: "sections";
+    allow: string[];
+    max?: number;
+} | {
+    kind: "freeform";
+    allow: string[] | "*";
+    rows: boolean;
+} | {
+    kind: "locked";
+    component: string;
+};
+export declare const z: {
+    sections(components: WithSchema[]): {
+        kind: "sections";
+        allow: string[];
+    } & {
+        max(n: number): ZonePolicy;
+    };
+    freeform(opts: {
+        sections: WithSchema[] | "*";
+        rows?: boolean;
+    }): ZonePolicy;
+    locked(component: WithSchema): ZonePolicy;
+};
+export {};