smoodly 0.0.1

package/dist/admin/tree-ops.js

@@ -0,0 +1,112 @@
+export function zoneOf(tree, id) {
+    for (const [zone, nodes] of Object.entries(tree.zones)) {
+        if (nodes.some((n) => n.id === id))
+            return zone;
+    }
+    return null;
+}
+export function findNode(tree, id) {
+    for (const nodes of Object.values(tree.zones)) {
+        const hit = nodes.find((n) => n.id === id);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+const withZone = (tree, zone, nodes) => ({
+    ...tree,
+    zones: { ...tree.zones, [zone]: nodes },
+});
+export function insertNode(tree, zone, index, node) {
+    const list = tree.zones[zone] ?? [];
+    return withZone(tree, zone, [...list.slice(0, index), node, ...list.slice(index)]);
+}
+export function removeNode(tree, id) {
+    const zone = zoneOf(tree, id);
+    if (!zone)
+        return tree;
+    return withZone(tree, zone, tree.zones[zone].filter((n) => n.id !== id));
+}
+export function moveNode(tree, id, dir) {
+    const zone = zoneOf(tree, id);
+    if (!zone)
+        return tree;
+    const list = [...tree.zones[zone]];
+    const i = list.findIndex((n) => n.id === id);
+    const j = i + dir;
+    if (j < 0 || j >= list.length)
+        return tree;
+    [list[i], list[j]] = [list[j], list[i]];
+    return withZone(tree, zone, list);
+}
+export function patchNode(tree, id, ns, key, value) {
+    const zone = zoneOf(tree, id);
+    if (!zone)
+        return tree;
+    return withZone(tree, zone, tree.zones[zone].map((n) => (n.id === id ? { ...n, [ns]: { ...(n[ns] ?? {}), [key]: value } } : n)));
+}
+export function canInsert(policy, count) {
+    if (!policy || policy.kind === "locked")
+        return false;
+    if (policy.kind === "sections" && policy.max != null && count >= policy.max)
+        return false;
+    return true;
+}
+export function allowedSections(policy, all) {
+    if (!policy || policy.kind === "locked")
+        return [];
+    if (policy.allow === "*")
+        return all;
+    const allow = new Set(policy.allow);
+    return all.filter((s) => allow.has(s.name));
+}
+/** The empty value a fresh node's field starts at, by descriptor type.
+ * Shape matters: a list-valued field seeded with "" is a type lie that
+ * crashes the first section view that maps over it. */
+const EMPTY_BY_TYPE = { refList: [], object: {} };
+/** Media/number fields have no honest empty value — "" renders as a
+ * broken-image icon or a stray zero, worse than nothing at all. With no
+ * sample, leave the key out of `fields` entirely rather than seed a lie. */
+const ABSENT_WHEN_UNSAMPLED = new Set(["image", "video", "file", "number"]);
+export function nodeFromSample(section, id) {
+    const fields = {};
+    const styles = {};
+    for (const [key, d] of Object.entries(section.fields)) {
+        const sampled = section.sample?.[key];
+        if (sampled !== undefined)
+            fields[key] = sampled;
+        else if (ABSENT_WHEN_UNSAMPLED.has(d.type))
+            continue;
+        else
+            fields[key] = EMPTY_BY_TYPE[d.type] ?? "";
+    }
+    for (const [key, d] of Object.entries(section.styles)) {
+        const v = section.sample?.[key] ?? d.default;
+        if (v !== undefined)
+            styles[key] = v;
+    }
+    return { id, type: section.name, fields, styles };
+}
+/** A locked zone holds exactly one node the editor can never insert or
+ * remove — so someone has to put it there. This does, from the component's
+ * sample, for every locked zone that is empty or missing. Runs when the
+ * editor loads a draft, which also covers pages that predate a locked zone
+ * being added to their schema. Returns the same tree when nothing changed. */
+export function fillLockedZones(tree, policies, sections) {
+    let next = null;
+    for (const [zone, policy] of Object.entries(policies)) {
+        if (policy.kind !== "locked")
+            continue;
+        if ((tree.zones[zone] ?? []).length > 0)
+            continue;
+        const section = sections.find((s) => s.name === policy.component);
+        if (!section)
+            continue;
+        next ?? (next = { ...tree, zones: { ...tree.zones } });
+        next.zones[zone] = [nodeFromSample(section, newNodeId(section.name))];
+    }
+    return next ?? tree;
+}
+export function newNodeId(type) {
+    return `${type}-${crypto.randomUUID().slice(0, 8)}`;
+}

package/dist/admin/validate.d.ts

@@ -0,0 +1,10 @@
+export type FieldError = {
+    field: string;
+    message: string;
+};
+export declare function validateFields(values: Record<string, unknown>, descriptors: Record<string, {
+    type: string;
+    optional?: unknown;
+    options?: unknown;
+    max?: unknown;
+}>): FieldError[];

package/dist/admin/validate.js

@@ -0,0 +1,19 @@
+const isEmpty = (v) => v === undefined || v === null || v === "" || (Array.isArray(v) && v.length === 0);
+export function validateFields(values, descriptors) {
+    const errors = [];
+    for (const [field, d] of Object.entries(descriptors)) {
+        const value = values[field];
+        if (isEmpty(value)) {
+            if (d.optional !== true)
+                errors.push({ field, message: "Required." });
+            continue;
+        }
+        if (d.type === "select" && Array.isArray(d.options) && !d.options.includes(value)) {
+            errors.push({ field, message: `Must be one of: ${d.options.join(", ")}.` });
+        }
+        if (typeof d.max === "number" && typeof value === "string" && value.length > d.max) {
+            errors.push({ field, message: `Must be at most ${d.max} characters.` });
+        }
+    }
+    return errors;
+}

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import { type SupabaseClient } from "@supabase/supabase-js";
+import type { SmoodlyEnv } from "./env.ts";
+type ContentEnv = Pick<SmoodlyEnv, "url" | "secretKey" | "publishableKey">;
+export declare function clientOptions(env: ContentEnv): {
+    url: string;
+    key: string;
+    headers: Record<string, string>;
+};
+/** The server-side client the stores are built on. */
+export declare function createSmoodlyClient(env: ContentEnv): SupabaseClient;
+export {};

package/dist/client.js

@@ -0,0 +1,19 @@
+// How the secret reaches PostgREST. A JWT (the self-host service role, or
+// a cloud space key) rides as the bearer PostgREST derives the role from,
+// with the publishable key satisfying the API gateway's apikey check. A
+// Supabase `sb_secret_…` key is itself an apikey. Key *format*, not mode.
+import { createClient } from "@supabase/supabase-js";
+export function clientOptions(env) {
+    if (env.secretKey.startsWith("sb_secret_")) {
+        return { url: env.url, key: env.secretKey, headers: {} };
+    }
+    return { url: env.url, key: env.publishableKey, headers: { Authorization: `Bearer ${env.secretKey}` } };
+}
+/** The server-side client the stores are built on. */
+export function createSmoodlyClient(env) {
+    const options = clientOptions(env);
+    return createClient(options.url, options.key, {
+        global: { headers: options.headers },
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+}

package/dist/collections.d.ts

@@ -0,0 +1,39 @@
+import type { Descriptor } from "./fields.ts";
+import type { BuilderMap, NamespaceValues } from "./schema.ts";
+export type CollectionSchema<F extends BuilderMap = BuilderMap> = {
+    kind: "collection";
+    name: string;
+    title: string;
+    titleField?: string;
+    fields: Record<string, Descriptor>;
+    admin?: {
+        listColumns?: string[];
+        orderBy?: Record<string, "asc" | "desc">;
+    };
+    /** phantom: the entry value shape, used by f.ref target inference */
+    readonly __entry?: NamespaceValues<F>;
+};
+export declare function collection<F extends BuilderMap>(input: {
+    name: string;
+    title: string;
+    titleField?: string;
+    fields: F;
+    admin?: {
+        listColumns?: string[];
+        orderBy?: Record<string, "asc" | "desc">;
+    };
+}): CollectionSchema<F>;
+export type Toolset = {
+    marks?: string[];
+    nodes?: string[];
+    elements?: string[];
+};
+export declare function toolset(input: {
+    marks?: string[];
+    nodes?: string[];
+    elements?: {
+        schema: {
+            name: string;
+        };
+    }[];
+}): Toolset;

package/dist/collections.js

@@ -0,0 +1,22 @@
+export function collection(input) {
+    if (!input?.name)
+        throw new Error("smoodly: a collection requires a name.");
+    return {
+        kind: "collection",
+        name: input.name,
+        title: input.title,
+        titleField: input.titleField,
+        fields: Object.fromEntries(Object.entries(input.fields).map(([k, b]) => [k, b.descriptor])),
+        admin: input.admin,
+    };
+}
+export function toolset(input) {
+    const out = {};
+    if (input.marks)
+        out.marks = input.marks;
+    if (input.nodes)
+        out.nodes = input.nodes;
+    if (input.elements)
+        out.elements = input.elements.map((e) => e.schema.name);
+    return out;
+}

package/dist/config.d.ts

@@ -0,0 +1,49 @@
+import type { Descriptor, FieldBuilder } from "./fields.ts";
+import type { CollectionSchema } from "./collections.ts";
+type Registered = {
+    schema: {
+        kind: string;
+        name: string;
+        slug?: string;
+        styles?: Record<string, Descriptor>;
+        styleDefaults?: false | {
+            omit: string[];
+        };
+    };
+};
+export type SmoodlyConfig = {
+    registry: {
+        sections?: Registered[];
+        elements?: Registered[];
+        collections?: CollectionSchema<any>[];
+        pages?: Registered[];
+    };
+    locales: {
+        default: string;
+        supported: string[];
+    };
+    styles?: {
+        sections?: Record<string, FieldBuilder<any, any>>;
+        elements?: Record<string, FieldBuilder<any, any>>;
+    };
+    rows?: {
+        splits: string[];
+    };
+    /** Slug of the page record the site root serves. The admin maps this
+     * slug to "/" (canvas URL, Pages list) and every other slug to
+     * "/<slug>"; the route file serving "/" must declare the same slug. */
+    homePageSlug?: string;
+    meta?: {
+        dataAttributes?: boolean;
+    };
+    database?: {
+        provider: string;
+    };
+};
+export type ResolvedConfig = SmoodlyConfig & {
+    homePageSlug: string;
+    /** The section's styles with the config standard set merged in (section keys win). */
+    resolvedStyles(sectionName: string): Record<string, Descriptor>;
+};
+export declare function defineConfig(config: SmoodlyConfig): ResolvedConfig;
+export {};

package/dist/config.js

@@ -0,0 +1,54 @@
+function assertUniqueNames(config) {
+    const seen = new Set();
+    const all = [
+        ...(config.registry.sections ?? []).map((s) => s.schema.name),
+        ...(config.registry.elements ?? []).map((e) => e.schema.name),
+        ...(config.registry.collections ?? []).map((c) => c.name),
+        ...(config.registry.pages ?? []).map((p) => p.schema.name),
+    ];
+    for (const name of all) {
+        if (seen.has(name))
+            throw new Error(`smoodly: duplicate registered name "${name}".`);
+        seen.add(name);
+    }
+}
+/** A fixed slug names the ONE page record a route file serves; two
+ * registrations claiming it would make which-one-renders undefined. */
+function assertUniqueFixedSlugs(config) {
+    const owners = new Map();
+    for (const p of config.registry.pages ?? []) {
+        const slug = p.schema.slug;
+        if (slug === undefined)
+            continue;
+        const owner = owners.get(slug);
+        if (owner) {
+            throw new Error(`smoodly: page registrations "${owner}" and "${p.schema.name}" both claim the fixed slug "${slug}".`);
+        }
+        owners.set(slug, p.schema.name);
+    }
+}
+export function defineConfig(config) {
+    assertUniqueNames(config);
+    assertUniqueFixedSlugs(config);
+    const standard = Object.fromEntries(Object.entries(config.styles?.sections ?? {}).map(([k, b]) => [k, b.descriptor]));
+    const byName = new Map((config.registry.sections ?? []).map((s) => [s.schema.name, s.schema]));
+    return {
+        ...config,
+        homePageSlug: config.homePageSlug ?? "home",
+        resolvedStyles(sectionName) {
+            const schema = byName.get(sectionName);
+            if (!schema)
+                throw new Error(`smoodly: unknown section "${sectionName}".`);
+            const own = schema.styles ?? {};
+            if (schema.styleDefaults === false)
+                return { ...own };
+            const omitted = new Set(schema.styleDefaults ? schema.styleDefaults.omit : []);
+            const merged = {};
+            for (const [k, d] of Object.entries(standard)) {
+                if (!omitted.has(k))
+                    merged[k] = d;
+            }
+            return { ...merged, ...own };
+        },
+    };
+}

package/dist/entry-store.d.ts

@@ -0,0 +1,74 @@
+import type { CollectionSchema } from "./collections.ts";
+import { MemoryRefIndex } from "./ref-index.ts";
+export type EntryRecord = {
+    id: string;
+    collection: string;
+    fields: Record<string, unknown>;
+    status: "draft" | "published";
+    sort: number | null;
+    createdAt: number;
+    updatedAt: number;
+};
+export type EntryUsage = {
+    sourceKind: string;
+    sourceId: string;
+    sourceField: string;
+};
+export type ListOptions = {
+    /** "created" (default): oldest first. "updated": recent first. "manual": sort asc. */
+    order?: "created" | "updated" | "manual";
+    status?: "published";
+};
+export interface EntryStore {
+    create(collection: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    get(collection: string, id: string): Promise<EntryRecord | null>;
+    list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
+    /** Batched read for the resolver: fields keyed by id, missing ids omitted.
+     * The signature IS resolveTree's EntryFetcher. The published-route
+     * resolver passes { status: "published" } so an entry demoted to draft
+     * after a referencing page was published drops out on the next
+     * revalidation instead of hydrating draft fields (DESIGN.md OQ #16). */
+    getMany(collection: string, ids: string[], options?: {
+        status?: "published";
+    }): Promise<Record<string, Record<string, unknown>>>;
+    update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    /** Blocked while anything references the entry (the safe-delete guard). */
+    delete(collection: string, id: string): Promise<void>;
+    /** Rewrite manual order to 1..N for the given ids, one batched pass. */
+    reorder(collection: string, orderedIds: string[]): Promise<void>;
+    /** The refs index's reverse question: who points at this entry? */
+    referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
+    /** Reverse lookup by id alone (ids are globally unique) — what the
+     * fan-out walk queries, since it can't know a source's collection. */
+    incoming(targetId: string): Promise<{
+        sourceKind: string;
+        sourceId: string;
+    }[]>;
+}
+export declare function schemaOf(collections: CollectionSchema<any>[], name: string): CollectionSchema<any>;
+export declare class MemoryEntryStore implements EntryStore {
+    private collections;
+    private refs;
+    private entries;
+    private seq;
+    private order;
+    constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex);
+    private row;
+    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>>>;
+    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>;
+    referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
+    incoming(targetId: string): Promise<{
+        sourceKind: string;
+        sourceId: string;
+    }[]>;
+}

package/dist/entry-store.js

@@ -0,0 +1,132 @@
+// The collection-entry persistence contract — the entries counterpart
+// to PageStore. Writes always flow through this API (never raw table
+// access), which is what lets the refs index stay correct: every save
+// rewrites the entry's outgoing edges (collectEntryRefs), so
+// referencesTo/safe-delete answer from the index alone. Status-only
+// versioning in v1 (DESIGN.md §3). Reorder rewrites sort 1..N in one
+// pass and NEVER touches updatedAt — order is a property of the
+// collection, not an edit to its entries.
+import { collectEntryRefs } from "./refs.js";
+import { MemoryRefIndex } from "./ref-index.js";
+export function schemaOf(collections, name) {
+    const schema = collections.find((c) => c.name === name);
+    if (!schema)
+        throw new Error(`smoodly: no collection named "${name}".`);
+    return schema;
+}
+let counter = 0;
+const uid = () => `entry-${++counter}-${Date.now().toString(36)}`;
+export class MemoryEntryStore {
+    constructor(collections, 
+    // pass the SAME index to MemoryPageStore so cross-kind questions work
+    refs = new MemoryRefIndex()) {
+        this.collections = collections;
+        this.refs = refs;
+        this.entries = new Map();
+        this.seq = 0; // creation-order tiebreak (Date.now can tie)
+        this.order = new Map();
+    }
+    row(collection, id) {
+        const entry = this.entries.get(id);
+        return entry && entry.collection === collection ? entry : null;
+    }
+    writeRefs(collection, id, fields) {
+        const schema = schemaOf(this.collections, collection);
+        this.refs.rewrite({ sourceKind: "entry", sourceId: id }, collectEntryRefs(fields, schema));
+    }
+    async create(collection, fields) {
+        schemaOf(this.collections, collection);
+        const now = Date.now();
+        const entry = {
+            id: uid(),
+            collection,
+            fields: structuredClone(fields),
+            status: "draft",
+            sort: null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.entries.set(entry.id, entry);
+        this.order.set(entry.id, ++this.seq);
+        this.writeRefs(collection, entry.id, fields);
+        return structuredClone(entry);
+    }
+    async get(collection, id) {
+        const entry = this.row(collection, id);
+        return entry ? structuredClone(entry) : null;
+    }
+    async list(collection, options) {
+        schemaOf(this.collections, collection);
+        let rows = [...this.entries.values()].filter((e) => e.collection === collection);
+        if (options?.status)
+            rows = rows.filter((e) => e.status === options.status);
+        const order = options?.order ?? "created";
+        rows.sort((a, b) => {
+            if (order === "updated")
+                return b.updatedAt - a.updatedAt;
+            if (order === "manual") {
+                const sa = a.sort ?? Infinity;
+                const sb = b.sort ?? Infinity;
+                if (sa !== sb)
+                    return sa - sb;
+            }
+            return this.order.get(a.id) - this.order.get(b.id);
+        });
+        return rows.map((e) => structuredClone(e));
+    }
+    async getMany(collection, ids, options) {
+        schemaOf(this.collections, collection);
+        const out = {};
+        for (const id of ids) {
+            const entry = this.row(collection, id);
+            if (!entry)
+                continue;
+            if (options?.status && entry.status !== options.status)
+                continue;
+            out[id] = structuredClone(entry.fields);
+        }
+        return out;
+    }
+    async update(collection, id, fields) {
+        const entry = this.row(collection, id);
+        if (!entry)
+            throw new Error(`smoodly: no entry "${id}" in "${collection}".`);
+        entry.fields = structuredClone(fields);
+        entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
+        this.writeRefs(collection, id, fields);
+        return structuredClone(entry);
+    }
+    async setStatus(collection, id, status) {
+        const entry = this.row(collection, id);
+        if (!entry)
+            throw new Error(`smoodly: no entry "${id}" in "${collection}".`);
+        entry.status = status;
+        entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
+        return structuredClone(entry);
+    }
+    async delete(collection, id) {
+        const entry = this.row(collection, id);
+        if (!entry)
+            return;
+        const usage = await this.referencesTo(collection, id);
+        if (usage.length > 0) {
+            throw new Error(`smoodly: "${collection}/${id}" is referenced by ${usage.length} document(s) — remove those references first.`);
+        }
+        this.entries.delete(id);
+        this.refs.remove({ sourceKind: "entry", sourceId: id });
+    }
+    async reorder(collection, orderedIds) {
+        schemaOf(this.collections, collection);
+        orderedIds.forEach((id, i) => {
+            const entry = this.row(collection, id);
+            if (entry)
+                entry.sort = i + 1; // deliberately NOT touching updatedAt
+        });
+    }
+    async referencesTo(collection, id) {
+        return this.refs.to(collection, id);
+    }
+    async incoming(targetId) {
+        return this.refs.incoming(targetId);
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,16 @@
+export type SmoodlyEnv = {
+    /** The content project. */
+    url: string;
+    /** Server-only: the service-role key (self-host) or the environment's write key (cloud). */
+    secretKey: string;
+    /** What a browser may hold for the content project: anon/publishable key, or the read key. */
+    publishableKey: string;
+    /** Where editors sign in. Defaults to `url`. */
+    authUrl: string;
+    /** That project's publishable key. Defaults to `publishableKey`. */
+    authKey: string;
+};
+export declare function resolveSmoodlyEnv(env: Record<string, string | undefined>): SmoodlyEnv;
+/** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
+ *  so `next build` without env still succeeds. */
+export declare const smoodlyEnv: () => SmoodlyEnv;

package/dist/env.js

@@ -0,0 +1,22 @@
+// The one config shape (spec 2026-09-04 §4/§6). Self-host sets three
+// names; the cloud sets five. The two defaults are what keep a single
+// code path: a default for an absent value is not a mode branch.
+const REQUIRED = ["SMOODLY_URL", "SMOODLY_SECRET_KEY", "SMOODLY_PUBLISHABLE_KEY"];
+export function resolveSmoodlyEnv(env) {
+    const missing = REQUIRED.filter((name) => !env[name]);
+    if (missing.length > 0) {
+        throw new Error(`smoodly: set ${missing.join(", ")} — see .env.local.example.`);
+    }
+    const url = env.SMOODLY_URL;
+    const publishableKey = env.SMOODLY_PUBLISHABLE_KEY;
+    return {
+        url,
+        secretKey: env.SMOODLY_SECRET_KEY,
+        publishableKey,
+        authUrl: env.SMOODLY_AUTH_URL || url,
+        authKey: env.SMOODLY_AUTH_KEY || publishableKey,
+    };
+}
+/** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
+ *  so `next build` without env still succeeds. */
+export const smoodlyEnv = () => resolveSmoodlyEnv(process.env);

package/dist/fields.d.ts

@@ -0,0 +1,67 @@
+export type Descriptor = {
+    type: string;
+    [key: string]: unknown;
+};
+export type FieldBuilder<Value = unknown, Flags extends BuilderFlags = {}> = {
+    readonly descriptor: Descriptor;
+    optional(): FieldBuilder<Value, Flags & {
+        optional: true;
+    }>;
+    localized(): FieldBuilder<Value, Flags & {
+        localized: true;
+    }>;
+    max(n: number): FieldBuilder<Value, Flags>;
+    min(n: number): FieldBuilder<Value, Flags>;
+    default(v: Value): FieldBuilder<Value, Flags>;
+    /**
+     * Resolution depth for this ref (decided at the ref site — a target
+     * schema's own annotations never deepen a chain):
+     * - `.resolve()` — follow the whole reference chain (cycle-safe)
+     * - `.resolve("company")` / `.resolve({ company: true })` — follow only
+     *   the named refs, one level; object values nest deeper
+     * - no call — hydrate the entry itself; its refs stay ids
+     */
+    resolve(...projection: (string | Record<string, unknown>)[]): FieldBuilder<Value, Flags>;
+    tab(tab: "content" | "styles" | "media" | "meta"): FieldBuilder<Value, Flags>;
+    /** phantom, type-level only */
+    readonly __value?: Value;
+    readonly __flags?: Flags;
+};
+export type BuilderFlags = {
+    optional?: true;
+    localized?: true;
+};
+export declare const f: {
+    text: () => FieldBuilder<string, {}>;
+    link: () => FieldBuilder<string, {}>;
+    slug: (opts?: {
+        from?: string;
+    }) => FieldBuilder<string, {}>;
+    date: () => FieldBuilder<string, {}>;
+    number: () => FieldBuilder<number, {}>;
+    image: () => FieldBuilder<{
+        url: string;
+        alt?: string;
+    }, {}>;
+    video: () => FieldBuilder<{
+        url: string;
+    }, {}>;
+    file: () => FieldBuilder<{
+        url: string;
+    }, {}>;
+    richtext: (opts?: {
+        toolset?: unknown;
+    }) => FieldBuilder<unknown, {}>;
+    dataAttributes: () => FieldBuilder<Record<string, string>, {}>;
+    select: <const O extends readonly string[]>(options: O) => FieldBuilder<O[number], {}>;
+    object: <S extends Record<string, FieldBuilder<any, any>>>(shape: S) => FieldBuilder<{ [K in keyof S]: ValueOf<S[K]>; }, {}>;
+    ref: <T>(target: () => T) => FieldBuilder<Resolved<T>, {}>;
+    refList: <T>(target: () => T) => FieldBuilder<Resolved<T>[], {}>;
+};
+export type ValueOf<B> = B extends FieldBuilder<infer V, infer Flags> ? Flags extends {
+    optional: true;
+} ? V | undefined : V : never;
+/** Resolved entry for a ref target — refined when collections land. */
+export type Resolved<T> = T extends {
+    __entry?: infer E;
+} ? E : Record<string, unknown>;