smoodly 0.0.51 → 0.0.53

package/dist/site.js

@@ -1,15 +1,9 @@
-import { schemaOf } from "./entry-store.js";
-import { entrySegment } from "./paths.js";
 import { lastPart } from "./addresses.js";
 import { withDefaults } from "./field-defaults.js";
 import { modelKey } from "./model-key.js";
-import { documentStamp } from "./document-stamp.js";
 import { SMOODLY_VERSION } from "./version.js";
-import { toEntryItem, toPageItem } from "./read-shapes.js";
 import { pageSeo } from "./seo.js";
-import { checkEntryQuery, createAssembler, pageFieldsOf, siteShape } from "./assemble.js";
-import { collectionOrder } from "./collections.js";
-import { createProjector } from "./project.js";
+import { pageFieldsOf, siteShape } from "./assemble.js";
 /** The `page` prop for a loaded page. `href` is the app's seam from a
  *  locale-relative path to a site URL; the default keeps CMS paths as URLs. */
 export function pageContextOf(hit, href = (p) => p) {
@@ -26,10 +20,11 @@ export function pageContextOf(hit, href = (p) => p) {
         locales: Object.fromEntries(Object.entries(hit.locales).map(([code, alt]) => [code, alt && { ...alt, url: href(alt.path, code) }])),
     };
 }
-export function createSmoodlySite(options) {
+/** The members of a site that need no store (the API client computes them from the same config, so a cache key or a
+ *  code page never disagrees across the wire). */
+export function siteStatics(options) {
     const shape = siteShape(options);
     const { locales, pageSchemas, homePageSlug, styles, custom, codeOwned } = shape;
-    const assembler = createAssembler(options, shape);
     // Every cached read keys on it (spec 2026-09-30 tester findings §3): an upgrade or a model change starts a fresh cache.
     const cacheKey = `${SMOODLY_VERSION}:${modelKey({
         // Whole schemas: a collection's order, tree or title field changes a read as its fields do (functions drop out in the hash).
@@ -39,206 +34,9 @@ export function createSmoodlySite(options) {
         elements: (options.elements ?? []).map((x) => ("schema" in x ? x.schema : x)),
         pages: pageSchemas,
         locales, homePageSlug, styles, custom,
+        // The project's image quality and cap are stamped on every image a read resolves.
+        images: options.images ?? {},
     })}`;
-    // What a delivery row is stamped with (DESIGN §3, the document stamp): the document format and the schema parts
-    // that reach a document, never the package version, so a release leaves current documents current.
-    const stamp = documentStamp(options);
-    const localeOf = (o) => o?.locale ?? locales.default;
-    const published = () => options.stores().published;
-    const projector = createProjector({
-        assembler,
-        stores: () => { const s = options.stores(); return { pages: s.pages, entries: s.entries, published: s.published }; },
-        collections: options.collections, globals: options.globals ?? [], sections: options.sections, elements: options.elements,
-        locales, model: stamp,
-    });
-    // Delivery (spec 2026-10-07 delivery model §3–§4): outside draft mode a read takes the stored document when it is
-    // current — built by this model and not marked stale — and otherwise assembles that one document, stores it and serves it.
-    const current = (row) => row.model === stamp && !row.stale;
-    /** One writer of record (DESIGN §3, the document stamp): only the deployment whose stamp the space recorded rewrites
-     *  rows; the first writer into an empty record records itself; every other deployment serves assembled documents
-     *  and writes nothing. Read only when a heal is about to write, so a current page stays one call. A "no" is kept for
-     *  the process (a later rebuild at this stamp is seen by the next process, which costs assembled reads, never wrong
-     *  ones); a "yes" is read again on each heal, so a rebuild elsewhere stops this writer at its next heal. */
-    let yields = false;
-    async function mayWrite() {
-        if (yields)
-            return false;
-        // The record is derived like the rows: a read or write of it that fails is logged, and the page is served
-        // assembled with nothing written (spec 2026-10-07 §2 Failure), never failed on it.
-        try {
-            const recorded = await published().recordedModel();
-            if (recorded === null) {
-                await published().recordModel(stamp);
-                return true;
-            }
-            yields = recorded !== stamp;
-            return !yields;
-        }
-        catch (e) {
-            console.error("smoodly: reading the space's recorded document stamp failed; served assembled, nothing written.", e);
-            return false;
-        }
-    }
-    const fresh = (row) => current(row) && row.document != null;
-    const itemOf = (doc) => toEntryItem(doc.entry, doc.entry.fields, { path: doc.path, locale: doc.locale, locales: doc.locales, ...(doc.seo ? { seo: doc.seo } : {}) });
-    /** A page row's answer: its document when current (null for a folder or a hidden node), else the healed one. */
-    const pageOf = async (row, id, locale) => row && current(row) ? row.document : projector.healPage(id, locale, { seen: row !== null, write: await mayWrite() });
-    /** An entry document is served at an address only when its collection has addresses. */
-    const served = (doc) => (doc && doc.path !== null ? doc : null);
-    const entryOf = async (row, id, locale) => row && fresh(row) ? row.document : projector.healEntry(id, locale, { seen: row !== null, write: await mayWrite() });
-    /** An entry document as the projector would write it, from an assembled read (the address-less shape, path from the item). */
-    const assembledEntry = (collection, locale) => (read) => ({
-        kind: "entry", locale, collection, entry: { ...read.record, fields: read.item.fields },
-        path: read.item.path, locales: read.item.locales, ...(read.item.seo ? { seo: read.item.seo } : {}),
-    });
-    /** The published documents of a collection's query. Stale rows are rebuilt in one batched projection and the
-     *  query read once more (spec §4): a rebuild that finds an entry unpublished removes its row, so it drops out. */
-    async function deliveredEntries(collection, o) {
-        const schema = schemaOf(options.collections, collection);
-        checkEntryQuery(schema, collection, o);
-        const locale = localeOf(o);
-        const read = () => published().entries(collection, {
-            locale, where: o.where, order: o.order ?? collectionOrder(schema), limit: o.limit, ids: o.ids,
-            ...(o.parent !== undefined ? { parent: o.parent } : {}),
-        });
-        let rows = await read();
-        const behind = rows.filter((r) => !fresh(r)).map((r) => r.id);
-        if (behind.length > 0) {
-            // Not the writer of record: the list assembled now, nothing written (DESIGN §3).
-            if (!(await mayWrite()))
-                return (await assembler.entries(collection, { ...o, locale, draft: false })).map(assembledEntry(collection, locale));
-            // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
-            try {
-                await projector.entries(behind, { cap: Infinity, stamp: false });
-                rows = await read();
-            }
-            catch (e) {
-                console.error(`smoodly: rebuilding ${behind.length} ${collection} documents in the delivery tables failed; served as read.`, e);
-            }
-        }
-        return rows.flatMap((r) => (r.document != null ? [r.document] : []));
-    }
-    const getEntries = async (collection, o = {}) => o.draft ? (await assembler.entries(collection, o)).map((r) => r.item) : (await deliveredEntries(collection, o)).map(itemOf);
-    /** Every entry of the collection in the locale, with the record a tree and a bare slug read `parentId` from. */
-    const readAll = async (collection, locale, draft) => draft
-        ? assembler.entries(collection, { locale, draft })
-        : (await deliveredEntries(collection, { locale })).map((doc) => ({ record: doc.entry, item: itemOf(doc) }));
-    const api = {
-        async getPagesTree(o) {
-            const locale = localeOf(o);
-            if (o?.draft)
-                return assembler.tree(locale, { draft: true });
-            // One light read. A row behind the model or marked stale is rebuilt before answering (spec §4), and the tree read
-            // again; a rebuild that finds the node gone or unpublished removes its row.
-            let rows = await published().tree(locale);
-            const behind = rows.filter((r) => !current(r)).map((r) => r.id);
-            if (behind.length > 0) {
-                // Not the writer of record: the tree assembled now, nothing written (DESIGN §3).
-                if (!(await mayWrite()))
-                    return assembler.tree(locale, { draft: false });
-                // One batched projection for every row behind (one tree read in the projector), then one more tree read.
-                // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
-                try {
-                    await projector.pages(behind, { cap: Infinity, stamp: false });
-                    rows = await published().tree(locale);
-                }
-                catch (e) {
-                    console.error(`smoodly: rebuilding ${behind.length} page documents in the delivery tables failed; served as read.`, e);
-                }
-            }
-            // A node the tree hides (path null) leaves with its subtree, as does one whose parent has no row.
-            const build = (parentId) => rows.filter((r) => r.parentId === parentId && r.path !== null).map((r) => ({
-                id: r.id, title: r.title, path: r.path, hasPage: r.hasPage, fields: r.linkFields, children: build(r.id),
-            }));
-            return build(null);
-        },
-        async getPage(pathOrId, o) {
-            const locale = localeOf(o);
-            if (!o?.draft) {
-                // The content API stays strict (§7): a redirect row, and a code-owned page with no record, are not pages.
-                const hit = pathOrId.startsWith("/")
-                    ? (await delivered(locale, pathOrId, false)).hit
-                    : await pageOf(await published().page(pathOrId, locale), pathOrId, locale);
-                return hit?.kind === "page" ? toPageItem(hit) : null;
-            }
-            const path = pathOrId.startsWith("/") ? pathOrId : (await options.stores().pages.pathsOf(pathOrId))[locale];
-            if (!path)
-                return null;
-            const hit = await site.resolve(locale, path, { draft: true });
-            return hit?.kind === "page" ? toPageItem(hit) : null;
-        },
-        getEntries,
-        async getEntry(collection, idOrPath, o) {
-            schemaOf(options.collections, collection); // an unknown collection is a wiring error on every branch
-            const locale = localeOf(o);
-            const draft = o?.draft ?? false;
-            if (idOrPath.startsWith("/")) {
-                const hit = draft ? await site.resolve(locale, idOrPath, { draft }) : (await delivered(locale, idOrPath, false)).hit;
-                return hit?.kind === "entry" && hit.collection === collection ? toEntryItem(hit.entry, hit.entry.fields, hit) : null;
-            }
-            if (draft) {
-                const [byId] = await assembler.entries(collection, { locale, draft, ids: [idOrPath] });
-                if (byId)
-                    return byId.item;
-            }
-            else {
-                const row = await published().entry(idOrPath, locale);
-                if (row && row.collection === collection && fresh(row))
-                    return itemOf(row.document);
-                // A miss is a record no projection wrote yet, or a slug: one `get` tells them apart.
-                if (row?.collection === collection || (await options.stores().entries.get(collection, idOrPath))) {
-                    const doc = await projector.healEntry(idOrPath, locale, { seen: row !== null, write: await mayWrite() });
-                    if (doc)
-                        return itemOf(doc);
-                }
-            }
-            // A bare slug names a ROOT entry only (sibling-scoped slugs, spec §4):
-            // match the localized slug directly (paths.ts owns slug derivation),
-            // regardless of whether the collection even has a `path`.
-            const all = await readAll(collection, locale, draft);
-            return all.find((r) => r.record.parentId === null && entrySegment(r.record, locale) === idOrPath)?.item ?? null;
-        },
-        async getEntriesTree(collection, o) {
-            const rows = await readAll(collection, localeOf(o), o?.draft ?? false);
-            const build = (parentId) => rows.filter((r) => r.record.parentId === parentId).map((r) => ({ ...r.item, children: build(r.record.id) }));
-            return build(null);
-        },
-        async getGlobal(item, o) {
-            const locale = localeOf(o);
-            if (o?.draft)
-                return assembler.global(item, locale, { draft: true });
-            // The item's row by its collection, in one read: a global is a one-record collection.
-            const [row] = await published().entries(item.name, { locale, limit: 1 });
-            return row && fresh(row) ? row.document : projector.healGlobal(item, locale, { seen: row !== undefined, write: await mayWrite() });
-        },
-    };
-    /** The published read of an address; `code`: the code-owned page answers where the index has no row. */
-    /** `globals`: the names of global items to bring along (schema v9); `rows` is what the route carried, when it had any. */
-    async function delivered(locale, path, code, globals) {
-        const route = await published().byAddress(locale, path, globals);
-        const rows = route?.globals;
-        if (route && fresh(route.row))
-            return { hit: route.row.document, rows };
-        let healed = null;
-        if (route) {
-            // Stale: rebuilt by id. Unpublished or moved since the row was written, the address is answered as a miss.
-            const write = await mayWrite();
-            healed = route.kind === "page" ? await projector.healPage(route.row.id, locale, { write }) : served(await projector.healEntry(route.row.id, locale, { write }));
-            if (healed && healed.path === path)
-                return { hit: healed, rows };
-        }
-        // A miss: the paths index doubles as the existence check — a record to assemble, a redirect row, or nothing.
-        // A record wins over the code-owned page at its address, as the renderer has it.
-        const hit = await site.locate(locale, path);
-        if (!hit)
-            return { hit: code ? codePage(locale, path) : null };
-        if (hit.redirect)
-            return { hit: { kind: "redirect", target: { kind: hit.kind, id: hit.id } } };
-        if (route && hit.id === route.row.id)
-            return { hit: healed, rows }; // just rebuilt
-        // By id: a page the tree hides has a current row the address lookup cannot reach; anything else heals there.
-        return { hit: await site.load(hit, locale, path), rows };
-    }
     const codePath = (address) => (address === homePageSlug ? "/" : `/${address}`);
     function codePage(locale, path) {
         const spec = codeOwned.find((a) => a.template !== null && a.segments[locale] !== undefined && codePath(a.segments[locale]) === path);
@@ -262,50 +60,21 @@ export function createSmoodlySite(options) {
             ...(withSeo ? { seo: pageSeo(undefined, spec.title) } : {}),
         };
     }
-    const site = {
-        locales,
-        homePageSlug,
-        cacheKey,
-        stamp,
-        styles,
-        custom,
-        locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
-        targetPaths: (target) => options.stores().pages.targetPaths(target),
-        async load(target, locale, path, opts = {}) {
-            const draft = opts.draft ?? false;
-            // Draft mode assembles from the editing tables; so does a stored version, which outside draft mode is nothing.
-            if (draft || opts.version !== undefined) {
-                return target.kind === "page" ? assembler.page(target.id, locale, path, { draft, version: opts.version }) : assembler.entry(target.id, locale, path, { draft });
-            }
-            return target.kind === "page"
-                ? pageOf(await published().page(target.id, locale), target.id, locale)
-                : served(await entryOf(await published().entry(target.id, locale), target.id, locale));
-        },
-        lookup: async (locale, path) => (await delivered(locale, path, true)).hit,
-        async lookupWithGlobals(locale, path, items) {
-            const { hit, rows } = await delivered(locale, path, true, items.map((i) => i.name));
-            const globals = new Map();
-            if (rows) {
-                for (const item of items) {
-                    const row = rows.find((r) => r.collection === item.name);
-                    // No row: unpublished here, or never projected — left out rather than healed on every read, because a
-                    // heal of an unpublished item writes nothing and the next read would heal again; the layout's own read
-                    // pays the call where a page renders it. A stale row heals once and is written.
-                    if (!row)
-                        continue;
-                    globals.set(item.name, fresh(row) ? row.document : await projector.healGlobal(item, locale, { seen: true, write: await mayWrite() }));
-                }
-            }
-            return { hit, globals };
-        },
-        async resolve(locale, path, opts) {
-            // The content API stays strict (§7): a content address is not a redirect.
-            const target = await site.locate(locale, path);
-            return target && !target.redirect ? site.load(target, locale, path, opts) : null;
+    return { shape, locales, homePageSlug, styles, custom, cacheKey, codePage };
+}
+/** What createSmoodlySite takes, read off the config. */
+export function siteOptions(config, stores) {
+    const { sections, elements, collections, globals, pages } = config.registry;
+    return {
+        // Absent for a site that reads over the API (api-client.ts): its statics need no store, and it never calls this.
+        stores: stores ?? (() => { throw new Error("smoodly: this site reads over the API — no store is bound."); }),
+        collections, globals,
+        // defineConfig's checks guarantee a section and an element carry `fields`.
+        sections: sections, elements: elements,
+        locales: config.locales, homePageSlug: config.homePageSlug, styles: config.styles, custom: config.custom, pages,
+        images: {
+            ...(config.media.quality !== undefined ? { quality: config.media.quality } : {}),
+            ...(config.media.maxWidth !== undefined ? { maxWidth: config.media.maxWidth } : {}),
         },
-        codePage,
-        projector,
-        ...api,
     };
-    return site;
 }

package/dist/space-transfer.d.ts

@@ -1,4 +1,6 @@
-import { type ContentTable } from "./sql-space.ts";
+/** The tables a space's content lives in, the ones export and import carry (members are listed, never copied). */
+export declare const CONTENT_TABLES: readonly ["pages", "page_locales", "page_versions", "entries", "entry_locales", "entry_versions", "refs", "paths", "assets"];
+export type ContentTable = (typeof CONTENT_TABLES)[number];
 /** The folder layout's own version, apart from the schema (spec §7). */
 export declare const FORMAT = 1;
 export type Row = Record<string, unknown>;
@@ -25,7 +27,7 @@ export type Manifest = {
 export declare const INSERT_ORDER: readonly ContentTable[];
 /** A row's identity inside one space: its primary key without `space_id`. */
 export declare const ROW_KEY: Record<ContentTable, readonly string[]>;
-/** The primary key as Postgres declares it — what "on conflict do nothing" names. */
+/** The primary key, in column order — what the import's skip-duplicates names. */
 export declare const CONFLICT_COLUMNS: Record<ContentTable, string>;
 export declare const rowKey: (table: ContentTable, row: Row) => string;
 /** Sorted by key, so two exports of an unchanged space diff cleanly (spec §7). */
@@ -56,5 +58,6 @@ export declare function describeExport(rows: TableRows, bytes: number): string;
 export declare function describeImport(rows: TableRows): string;
 /** The target check's refusal (spec §9.1), naming only the tables that hold foreign rows. */
 export declare function notEmptyMessage(foreign: Record<ContentTable, number>): string;
-/** Spec §6: the target database's version must equal the export's. */
+/** Spec §6: the target space's schema version must equal the export's. A space's schema is its object's step list,
+ *  brought forward by its service (spec 2026-10-15 the space object), so the fix is the other side's service. */
 export declare function versionMismatchMessage(target: number, exported: number): string;

package/dist/space-transfer.js

@@ -5,7 +5,18 @@
 // mirror of the target's foreign keys and the import's "only this
 // export's rows" test. No I/O; the CLI halves are cli/export.ts and
 // cli/import.ts.
-import { CONTENT_TABLES } from "./sql-space.js";
+/** The tables a space's content lives in, the ones export and import carry (members are listed, never copied). */
+export const CONTENT_TABLES = [
+    "pages",
+    "page_locales",
+    "page_versions",
+    "entries",
+    "entry_locales",
+    "entry_versions",
+    "refs",
+    "paths",
+    "assets",
+];
 /** The folder layout's own version, apart from the schema (spec §7). */
 export const FORMAT = 1;
 /** Every foreign key's target lands before the row that names it (spec §9.3). */
@@ -26,7 +37,7 @@ export const ROW_KEY = {
     paths: ["locale", "anchor", "path"],
     assets: ["id"],
 };
-/** The primary key as Postgres declares it — what "on conflict do nothing" names. */
+/** The primary key, in column order — what the import's skip-duplicates names. */
 export const CONFLICT_COLUMNS = Object.fromEntries(CONTENT_TABLES.map((t) => [t, (t === "paths" ? ["space_id", ...ROW_KEY[t]] : ROW_KEY[t]).join(",")]));
 export const rowKey = (table, row) => JSON.stringify(ROW_KEY[table].map((c) => row[c]));
 /** Sorted by key, so two exports of an unchanged space diff cleanly (spec §7). */
@@ -171,11 +182,12 @@ const NOUN = {
 /** The target check's refusal (spec §9.1), naming only the tables that hold foreign rows. */
 export function notEmptyMessage(foreign) {
     const parts = INSERT_ORDER.filter((t) => foreign[t] > 0).map((t) => plural(foreign[t], ...NOUN[t]));
-    return `The target space holds ${listJoin(parts)} that this export does not. Import needs an empty space: a new Supabase project, or \`supabase db reset\` on a local stack.`;
+    return `The target space holds ${listJoin(parts)} that this export does not. Import needs an empty space: import into a new one.`;
 }
-/** Spec §6: the target database's version must equal the export's. */
+/** Spec §6: the target space's schema version must equal the export's. A space's schema is its object's step list,
+ *  brought forward by its service (spec 2026-10-15 the space object), so the fix is the other side's service. */
 export function versionMismatchMessage(target, exported) {
     return target < exported
-        ? `The target database is at schema v${target} and this export is v${exported}: update smoodly to a version that ships v${exported}, run \`npx smoodly migrate\`, then \`supabase db push\`.`
-        : `The target database is at schema v${target}, newer than this export (v${exported}): migrate the source and export again.`;
+        ? `The target space is at schema v${target} and this export is v${exported}: a newer service wrote it. Import it into a space whose service has reached v${exported}.`
+        : `The target space is at schema v${target}, newer than this export (v${exported}): export the source again once its service has reached v${target}.`;
 }

package/dist/store.d.ts

@@ -4,9 +4,8 @@ import type { Addresses } from "./addresses.ts";
 import type { Anchors } from "./anchors.ts";
 import { type RefEdge, type SectionLike } from "./refs.ts";
 import type { Toolset } from "./toolset.ts";
-import type { MemoryRefIndex } from "./ref-index.ts";
-import { type PathHit, type PathIndex, type PathRow } from "./path-index.ts";
-import { type DraftToken } from "./draft-token.ts";
+import type { PathHit, PathIndex, PathRow } from "./path-index.ts";
+import type { DraftToken } from "./draft-token.ts";
 import { type LocaleSet, type PagePathOptions, type PathTarget } from "./paths.ts";
 export type PageLocale = {
     /** The node's OWN segment in this locale; the URL is derived (paths.ts). */
@@ -71,8 +70,6 @@ export interface PageStore {
     /** Every page with each locale's draft and live tree, in few reads (spec 2026-09-27 editor safety §3). */
     scanTrees(): Promise<PageScan[]>;
     resolvePath(locale: string, path: string): Promise<PathHit | null>;
-    /** The database's schema version from `smoodly_meta`; null when the table is missing (older than v1). Memory: always current (spec 2026-09-26 §5). */
-    schemaVersion(): Promise<number | null>;
     /** locale → path, for the locales the page exists in. */
     pathsOf(id: string): Promise<Record<string, string>>;
     /** locale → the target's live path, for any page or entry — the renderer's redirect branch (spec 2026-09-26 redirects §7). */
@@ -187,7 +184,6 @@ export declare const pageErrors: {
     fixedTaken: (key: string) => Error;
     fixedAtRoot: () => Error;
 };
-export { assertSupportedLocale } from "./paths.ts";
 /** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
 export declare function localeRow(page: PageRecord, locale: string): PageLocale;
 /** A page's refs rows cover EVERY live tree — each locale's draft and
@@ -199,77 +195,3 @@ export declare function pageRefEdges(trees: PageTree[], sections: SectionLike[],
  * THERE — every referenced entry must exist, have a row in that locale,
  * and be published in it. Throws naming the offenders. */
 export declare function assertPublishable(label: string, tree: PageTree, sections: SectionLike[], entries: EntryStore, locale: string): Promise<void>;
-export declare class MemoryPageStore implements PageStore {
-    private options;
-    private pages;
-    private versions;
-    /** Append-only creation-order tie-break; `size + 1` stays fresh only because entries are never deleted. */
-    private seq;
-    private paths;
-    private opts;
-    constructor(options?: PageStoreOptions & {
-        refs?: MemoryRefIndex;
-    });
-    private byId;
-    private must;
-    private isHome;
-    private snapshot;
-    private children;
-    private hasChildren;
-    private siblings;
-    /** Sibling slugs are unique per parent PER LOCALE — a friendlier error
-     *  than the path index's, which stays the real invariant. Code-owned
-     *  roots are left out: their path is their address, and the path index
-     *  guards it (spec 2026-09-29 nested paths §3). */
-    private assertSlugFree;
-    private subtree;
-    private writePaths;
-    /** Every locale's draft and published trees, deduped by version id. */
-    private liveTrees;
-    private writeRefs;
-    private newVersion;
-    /** The draft rule (spec 2026-09-13 history §1): the unpublished draft row is
-     *  rewritten in place; a new row starts only when the draft IS the published one. */
-    private writeDraftVersion;
-    private dropVersions;
-    createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
-    getPage(id: string): Promise<PageRecord | null>;
-    scanTrees(): Promise<PageScan[]>;
-    listPages(): Promise<PageRecord[]>;
-    resolvePath(locale: string, path: string): Promise<PathHit | null>;
-    schemaVersion(): Promise<number>;
-    pathsOf(id: string): Promise<Record<string, string>>;
-    targetPaths(target: PathTarget): Promise<Record<string, string>>;
-    redirectsOf(id: string): Promise<Record<string, string[]>>;
-    listLive(locale: string): Promise<PathRow[]>;
-    listRedirects(locale: string): Promise<PathRow[]>;
-    addRedirect(row: PathRow): Promise<void>;
-    removeRedirect(locale: string, path: string): Promise<void>;
-    addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
-    removeLocale(id: string, locale: string): Promise<PageRecord>;
-    rename(id: string, patch: {
-        locale: string;
-        slug?: string;
-        title?: string;
-    }, by?: string, options?: {
-        redirect?: boolean;
-    }): Promise<PageRecord>;
-    move(id: string, to: {
-        parentId: string | null;
-        index?: number;
-    }, options?: {
-        redirect?: boolean;
-    }): Promise<PageRecord>;
-    setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
-    saveDraft(id: string, locale: string, tree: PageTree, by?: string, expected?: DraftToken | null): Promise<PageVersion>;
-    publish(id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<PageRecord>;
-    discardDraft(id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<PageRecord>;
-    unpublish(id: string, locale: string, by?: string): Promise<PageRecord>;
-    restore(id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<PageRecord>;
-    getVersion(versionId: string): Promise<PageVersion | null>;
-    getDraftTree(id: string, locale: string): Promise<PageTree | null>;
-    fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
-    getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
-    listVersions(id: string, locale: string): Promise<PageVersion[]>;
-    deletePage(id: string): Promise<void>;
-}