smoodly 0.0.51 → 0.0.53

package/dist/migrations.js

@@ -1,73 +0,0 @@
-// packages/smoodly/src/migrations.ts
-// What `npx smoodly migrate` decides, as pure functions over file lists
-// (spec 2026-09-26 §2–§3): which package files the app lacks, which
-// collections need a fresh view block, and the one views file to write.
-// Node-only (crypto): exposed at `smoodly/migrations`, never from the
-// root index, which the client bundle reaches through the config.
-import { createHash } from "node:crypto";
-export const MARKER_PREFIX = "-- smoodly:collection ";
-const MARKER_RE = /^-- smoodly:collection (\S+) sha256:([0-9a-f]+)\s*$/gm;
-const OWN_FILE_RE = /^(\d{14})_smoodly_(v\d+|views)\.sql$/;
-/** The first 16 hex chars of sha256 over the exact emitted SQL. */
-export const collectionHash = (sql) => createHash("sha256").update(sql).digest("hex").slice(0, 16);
-export const collectionMarker = (c) => `${MARKER_PREFIX}${c.name} sha256:${collectionHash(c.sql)}`;
-/** name → hash, the LAST marker per collection across the files in name order. */
-export function parseMarkers(files) {
-    const out = new Map();
-    for (const file of [...files].sort((a, b) => a.name.localeCompare(b.name))) {
-        for (const m of file.text.matchAll(MARKER_RE))
-            out.set(m[1], m[2]);
-    }
-    return out;
-}
-/** UTC yyyyMMddHHmmss — the Supabase CLI's file-name prefix. */
-export const stamp = (at) => at.toISOString().replace(/\D/g, "").slice(0, 14);
-const stampDate = (s) => new Date(Date.UTC(+s.slice(0, 4), +s.slice(4, 6) - 1, +s.slice(6, 8), +s.slice(8, 10), +s.slice(10, 12), +s.slice(12, 14)));
-/** A views file must sort after every core file it may depend on and
- *  after any earlier views file it supersedes: the later of `now` and the
- *  newest own stamp plus a minute. */
-export function viewsStamp(names, now) {
-    let at = now;
-    for (const name of names) {
-        const m = OWN_FILE_RE.exec(name);
-        if (!m)
-            continue;
-        const after = new Date(stampDate(m[1]).getTime() + 60000);
-        if (after > at)
-            at = after;
-    }
-    return at;
-}
-/** One file with a block per new or changed collection; null when none changed. */
-export function viewsFile(collections, existing, at) {
-    const changed = collections.filter((c) => existing.get(c.name) !== collectionHash(c.sql));
-    if (changed.length === 0)
-        return null;
-    const text = "-- Smoodly: read views for this app's collections, written by `npx smoodly migrate`\n" +
-        `-- (${at.toISOString()}). One block per collection; the marker's hash is the block's SQL, compared on the next run.\n` +
-        "-- Never edit a written file: change the collection and run migrate again.\n\n" +
-        changed.map((c) => `${collectionMarker(c)}\n${c.sql.trim()}`).join("\n\n") +
-        "\n";
-    return { name: `${stamp(at)}_smoodly_views.sql`, text };
-}
-/** Package files the app lacks (copy) and same-named files whose text differs (modified — never overwritten). */
-export function pendingCoreFiles(packageFiles, appFiles) {
-    const app = new Map(appFiles.map((f) => [f.name, f.text]));
-    const copy = [];
-    const modified = [];
-    for (const file of [...packageFiles].sort((a, b) => a.name.localeCompare(b.name))) {
-        const have = app.get(file.name);
-        if (have === undefined)
-            copy.push(file);
-        else if (have !== file.text)
-            modified.push(file.name);
-    }
-    return { copy, modified };
-}
-export function planMigrate(input, now) {
-    const core = pendingCoreFiles(input.packageFiles, input.appFiles);
-    const names = [...input.packageFiles, ...input.appFiles].map((f) => f.name);
-    const views = viewsFile(input.collections, parseMarkers(input.appFiles), viewsStamp(names, now));
-    return { ...core, views };
-}
-export const planIsEmpty = (plan) => plan.copy.length === 0 && plan.modified.length === 0 && plan.views === null;

package/dist/project.d.ts

@@ -1,88 +0,0 @@
-import type { Assembler } from "./assemble.ts";
-import type { CollectionSchema } from "./collections.ts";
-import type { EntryStore } from "./entry-store.ts";
-import type { GlobalSchema } from "./global.ts";
-import type { LocaleSet } from "./paths.ts";
-import type { PublishedKey, PublishedStore } from "./published.ts";
-import { type SectionLike } from "./refs.ts";
-import type { SiteEntry, SitePage } from "./site.ts";
-import type { PageStore } from "./store.ts";
-/** The documents one projection writes before the rest are left to heal on read (§2). */
-export declare const PROJECTION_CAP = 100;
-/** `cap` overrides the projector's own for one call: a rebuild passes Infinity, a test a small number. `write`
- *  false (DESIGN §3, the document stamp): the rows are built but nothing is written, removed or marked — a reader
- *  whose stamp the space did not record. Default true. */
-export type ProjectOptions = {
-    cap?: number;
-    write?: boolean;
-    /** `false` (a behind rebuild on a read, spec 2026-10-09 static mode §5): an existing row keeps its publishedAt, so
-     *  the rebuild is not counted as a publish the static site has not got. Default true: a publish, `npx smoodly rebuild`. */
-    stamp?: boolean;
-};
-export type Projector = {
-    /** Writes the delivery rows of these pages in every supported locale (a row per visible locale, removed where not visible). Returns the keys it could not fit under the cap, already marked stale. */
-    pages(ids: string[], options?: ProjectOptions): Promise<PublishedKey[]>;
-    /** The same for entries and globals, by id (the collection is found through the registry). */
-    entries(ids: string[], options?: ProjectOptions): Promise<PublishedKey[]>;
-    /** One page document, one locale, written now: what heal-on-read calls. `seen`: the caller read a row for it,
-     *  so a target no longer visible has a row to remove; without one nothing is written. The write is best effort:
-     *  a failed put or remove is logged and the assembled document is served all the same. */
-    healPage(id: string, locale: string, options?: HealOptions): Promise<SitePage | null>;
-    healEntry(id: string, locale: string, options?: HealOptions): Promise<SiteEntry | null>;
-    healGlobal<V>(item: GlobalSchema<V>, locale: string, options?: HealOptions): Promise<V | null>;
-    /** Flags rows to rebuild on their next read: what an op does with the targets of a projection that threw. */
-    markStale(keys: PublishedKey[]): Promise<void>;
-    /** Records this projector's stamp as the space's current one (DESIGN §3): what a rebuild ends with. */
-    record(): Promise<void>;
-    /** The delivery tables against this stamp: how many rows are behind it, and which stamp the space recorded. */
-    delivery(): Promise<DeliveryStatus>;
-};
-/** What Content health and `migrate --check` show of the delivery tables (DESIGN §3, the document stamp). */
-export type DeliveryStatus = {
-    total: number;
-    behind: number;
-    recorded: string | null;
-    stamp: string;
-};
-/** `write` false: serve the assembled document, write and remove nothing (a reader at another stamp than the recorded one). */
-export type HealOptions = {
-    seen?: boolean;
-    write?: boolean;
-};
-export type ProjectorDeps = {
-    assembler: Assembler;
-    stores: () => {
-        pages: PageStore;
-        entries: EntryStore;
-        published: PublishedStore;
-    };
-    collections: CollectionSchema<any>[];
-    globals: GlobalSchema[];
-    /** The ref walk behind a page row's tags. */
-    sections: SectionLike[];
-    elements?: SectionLike[];
-    locales: LocaleSet;
-    /** The stamp a row is current against: the site's document stamp (§4; DESIGN §3). */
-    model: string;
-    cap?: number;
-};
-export declare function createProjector(deps: ProjectorDeps): Projector;
-export type ProjectAllDeps = {
-    stores: {
-        pages: PageStore;
-        entries: EntryStore;
-    };
-    projector: Projector;
-    /** Every registered collection's and global's name: the entries are listed per name. */
-    names: string[];
-    /** Ids per batch; each batch is written whole, past the projector's cap. */
-    cap?: number;
-};
-/** The rebuild (spec 2026-10-07 delivery model §2): every page and entry of the space projected, in batches of
- *  `cap` ids, none left stale, and the stamp recorded as the space's current one. Import ends with it, and `smoodly rebuild` is it. The counts are the pages and the
- *  entries (globals included) published in some locale; `stale` is what a batch could not write, 0 by design. */
-export declare function projectAll(deps: ProjectAllDeps): Promise<{
-    pages: number;
-    entries: number;
-    stale: number;
-}>;

package/dist/project.js

@@ -1,231 +0,0 @@
-import { ASSET_COLLECTION } from "./media.js";
-import { collectEntryRefs, collectTreeRefs } from "./refs.js";
-import { collectionTag, entryTag, globalTag, pageTag } from "./revalidate.js";
-/** The documents one projection writes before the rest are left to heal on read (§2). */
-export const PROJECTION_CAP = 100;
-/** The entry ids a document depends on (media is not an entry). */
-const entryTags = (edges) => edges.filter((e) => e.targetCollection !== ASSET_COLLECTION).map((e) => entryTag(e.targetId));
-const unique = (tags) => [...new Set(tags)];
-/** A heal's write is derived and the visitor's read must not fail on it (spec §2 Failure): logged, not thrown. */
-async function bestEffort(what, write) {
-    try {
-        await write();
-    }
-    catch (e) {
-        console.error(`smoodly: ${what} in the delivery tables failed; the next read rebuilds it.`, e);
-    }
-}
-export function createProjector(deps) {
-    const { assembler, collections, globals, locales, model } = deps;
-    const cap = deps.cap ?? PROJECTION_CAP;
-    const isGlobal = (schema) => schema.kind === "global";
-    /** The page's row in the locale, or null where the public does not see it (absent, or an unpublished page). */
-    async function pageRow(a, record, all, locale) {
-        const row = record.locales[locale];
-        if (!row || (record.template !== null && row.status !== "published"))
-            return null;
-        const light = await a.treeRow(record, all, locale);
-        // A folder is a row without a document. A page the tree hides (path null) keeps one at its live address, which
-        // the address lookup never reaches but a locate can (a record at a code address): the read takes it by id then.
-        const path = light.hasPage ? light.path ?? (await deps.stores().pages.pathsOf(record.id))[locale] ?? null : null;
-        const document = path !== null ? await a.page(record.id, locale, path, { draft: false }) : null;
-        const raw = document ? await deps.stores().pages.getPublishedTree(record.id, locale) : null;
-        const refs = raw ? entryTags(collectTreeRefs(raw, deps.sections, deps.elements)) : [];
-        return {
-            ...light, document,
-            tags: unique([pageTag(record.id), ...refs]),
-            model, stale: false, publishedAt: Date.now(),
-        };
-    }
-    /** The schema an entry id belongs to, and its record: one `get` per registered collection until found. */
-    async function findEntry(id) {
-        const { entries } = deps.stores();
-        for (const schema of [...collections, ...globals]) {
-            const record = await entries.get(schema.name, id);
-            if (record)
-                return { schema, record };
-        }
-        return null;
-    }
-    /** The entry's or global's row in the locale, or null where it is not published. A collection
-     *  without a `path` gets a document too (its list items), with `path` null. */
-    async function entryRow(a, schema, record, locale) {
-        const row = record.locales[locale];
-        if (!row || row.status !== "published")
-            return null;
-        const { entries } = deps.stores();
-        const fields = (await entries.getMany(schema.name, [record.id], locale, { status: "published" }))[record.id];
-        if (!fields)
-            return null;
-        let document;
-        let path = null;
-        if (isGlobal(schema)) {
-            document = await a.global(schema, locale, { draft: false });
-        }
-        else {
-            path = schema.path !== undefined ? (await entries.pathsOf(schema.name, record.id))[locale] ?? null : null;
-            if (path !== null) {
-                document = await a.entry(record.id, locale, path, { draft: false });
-            }
-            else {
-                // The list item is all an address-less entry serves: the same projection getEntries makes.
-                const [read] = await a.entries(schema.name, { locale, ids: [record.id] });
-                document = read && {
-                    kind: "entry", locale, collection: schema.name, entry: { ...read.record, fields: read.item.fields },
-                    path: null, locales: read.item.locales, ...(read.item.seo ? { seo: read.item.seo } : {}),
-                };
-            }
-        }
-        if (document == null)
-            return null;
-        return {
-            id: record.id, locale, collection: schema.name, parentId: record.parentId, sort: record.sort, slug: row.slug, path,
-            createdAt: record.createdAt, updatedAt: row.updatedAt, fields, document,
-            tags: unique([
-                entryTag(record.id), collectionTag(schema.name), ...(isGlobal(schema) ? [globalTag(schema.name)] : []),
-                ...entryTags(collectEntryRefs(fields, schema, deps.elements)),
-            ]),
-            model, stale: false, publishedAt: Date.now(),
-        };
-    }
-    /** Builds rows for each (id, locale) until the cap; the rest are marked stale and returned. */
-    async function project(cap, kind, targets, idOf, build, put, write) {
-        const { published } = deps.stores();
-        const rows = [];
-        const gone = [];
-        const over = [];
-        for (const t of targets) {
-            for (const locale of locales.supported) {
-                if (rows.length >= cap) {
-                    over.push({ kind, id: idOf(t), locale });
-                    continue;
-                }
-                const row = await build(t, locale);
-                if (row)
-                    rows.push(row);
-                else
-                    gone.push({ kind, id: idOf(t), locale });
-            }
-        }
-        if (!write)
-            return over;
-        if (rows.length > 0)
-            await put(rows);
-        if (gone.length > 0)
-            await published.remove(gone);
-        if (over.length > 0)
-            await published.markStale(over);
-        return over;
-    }
-    return {
-        async pages(ids, options) {
-            const write = options?.write !== false;
-            const all = await deps.stores().pages.listPages();
-            const a = assembler.batch({ pages: all });
-            const byId = new Map(all.map((p) => [p.id, p]));
-            // A page no longer in the tree has no row in any locale.
-            const missing = ids.filter((id) => !byId.has(id));
-            if (write && missing.length > 0)
-                await deps.stores().published.remove(missing.map((id) => ({ kind: "page", id })));
-            const keep = options?.stamp === false;
-            return project(options?.cap ?? cap, "page", ids.filter((id) => byId.has(id)).map((id) => byId.get(id)), (p) => p.id, (p, locale) => pageRow(a, p, all, locale), (rows) => deps.stores().published.putPages(rows, { keep }), write);
-        },
-        async entries(ids, options) {
-            const a = assembler.batch();
-            const found = [];
-            const missing = [];
-            for (const id of ids) {
-                const hit = await findEntry(id);
-                if (hit)
-                    found.push(hit);
-                else
-                    missing.push({ kind: "entry", id });
-            }
-            const write = options?.write !== false;
-            if (write && missing.length > 0)
-                await deps.stores().published.remove(missing);
-            const keep = options?.stamp === false;
-            return project(options?.cap ?? cap, "entry", found, (h) => h.record.id, (h, locale) => entryRow(a, h.schema, h.record, locale), (rows) => deps.stores().published.putEntries(rows, { keep }), write);
-        },
-        async healPage(id, locale, options) {
-            const { pages, published } = deps.stores();
-            // One record first: a page the public does not see in the locale costs no table read.
-            const record = await pages.getPage(id);
-            const row = record?.locales[locale];
-            const visible = row !== undefined && (record.template === null || row.status === "published");
-            const all = visible ? await pages.listPages() : [];
-            const projected = visible ? await pageRow(assembler.batch({ pages: all }), record, all, locale) : null;
-            const write = options?.write !== false;
-            if (!projected) {
-                if (write && options?.seen !== false)
-                    await bestEffort(`removing page ${id} (${locale})`, () => published.remove([{ kind: "page", id, locale }]));
-                return null;
-            }
-            // A heal keeps the row's publishedAt: it rebuilds what a publish wrote, it is not one (spec 2026-10-09 static mode §5).
-            if (write)
-                await bestEffort(`writing page ${id} (${locale})`, () => published.putPages([projected], { keep: true }));
-            return projected.document;
-        },
-        async healEntry(id, locale, options) {
-            const { published } = deps.stores();
-            const hit = await findEntry(id);
-            const row = hit ? await entryRow(assembler.batch(), hit.schema, hit.record, locale) : null;
-            const write = options?.write !== false;
-            if (!row) {
-                if (write && options?.seen !== false)
-                    await bestEffort(`removing entry ${id} (${locale})`, () => published.remove([{ kind: "entry", id, locale }]));
-                return null;
-            }
-            if (write)
-                await bestEffort(`writing entry ${id} (${locale})`, () => published.putEntries([row], { keep: true }));
-            return row.document;
-        },
-        async healGlobal(item, locale, options) {
-            const { entries, published } = deps.stores();
-            const [record] = await entries.list(item.name);
-            if (!record)
-                return null;
-            const row = await entryRow(assembler.batch(), item, record, locale);
-            const write = options?.write !== false;
-            if (!row) {
-                if (write && options?.seen !== false)
-                    await bestEffort(`removing global ${item.name} (${locale})`, () => published.remove([{ kind: "entry", id: record.id, locale }]));
-                return null;
-            }
-            if (write)
-                await bestEffort(`writing global ${item.name} (${locale})`, () => published.putEntries([row], { keep: true }));
-            return row.document;
-        },
-        markStale: (keys) => deps.stores().published.markStale(keys),
-        record: () => deps.stores().published.recordModel(model),
-        async delivery() {
-            const { published } = deps.stores();
-            const [counts, recorded] = await Promise.all([published.countBehind(model), published.recordedModel()]);
-            return { ...counts, recorded, stamp: model };
-        },
-    };
-}
-/** The rebuild (spec 2026-10-07 delivery model §2): every page and entry of the space projected, in batches of
- *  `cap` ids, none left stale, and the stamp recorded as the space's current one. Import ends with it, and `smoodly rebuild` is it. The counts are the pages and the
- *  entries (globals included) published in some locale; `stale` is what a batch could not write, 0 by design. */
-export async function projectAll(deps) {
-    const size = deps.cap ?? PROJECTION_CAP;
-    const whole = { cap: Infinity };
-    const published = (r) => Object.values(r.locales).some((l) => l?.status === "published");
-    let stale = 0;
-    const pages = await deps.stores.pages.listPages();
-    for (let i = 0; i < pages.length; i += size) {
-        stale += (await deps.projector.pages(pages.slice(i, i + size).map((p) => p.id), whole)).length;
-    }
-    const entries = (await Promise.all(deps.names.map((name) => deps.stores.entries.list(name)))).flat();
-    for (let i = 0; i < entries.length; i += size) {
-        stale += (await deps.projector.entries(entries.slice(i, i + size).map((e) => e.id), whole)).length;
-    }
-    // Every row now carries this stamp: it is the space's current one, and this deployment the writer of record (DESIGN §3).
-    await deps.projector.record();
-    return {
-        pages: pages.filter((p) => p.template !== null && published(p)).length,
-        entries: entries.filter(published).length,
-        stale,
-    };
-}

package/dist/published.d.ts

@@ -1,142 +0,0 @@
-import type { EntryOrder } from "./collections.ts";
-import { type Where } from "./entry-store.ts";
-import type { SiteEntry, SitePage } from "./site.ts";
-/** A page's delivery row: a published page, or a folder present in the locale (document null, hasPage false). */
-export type PublishedPageRow = {
-    id: string;
-    locale: string;
-    parentId: string | null;
-    sort: number | null;
-    /** The served address; null when the tree hides the node (no path, or a code address wins). */
-    path: string | null;
-    title: string;
-    hasPage: boolean;
-    /** The page fields with defaults, raw (no asset resolution): what a tree item and a link show. */
-    linkFields: Record<string, unknown>;
-    document: SitePage | null;
-    tags: string[];
-    /** The document stamp that built the row (document-stamp.ts); the column name predates the name. */
-    model: string;
-    stale: boolean;
-    publishedAt: number;
-};
-/** An entry's or a global's delivery row. A global's `document` is the value `getGlobal` returns; its collection is the item's name. */
-export type PublishedEntryRow = {
-    id: string;
-    locale: string;
-    collection: string;
-    parentId: string | null;
-    sort: number | null;
-    slug: string | null;
-    path: string | null;
-    createdAt: number;
-    updatedAt: number;
-    /** The published snapshot, raw, slug included: what `where` and `order` read. */
-    fields: Record<string, unknown>;
-    document: SiteEntry | unknown;
-    tags: string[];
-    /** The document stamp that built the row (document-stamp.ts); the column name predates the name. */
-    model: string;
-    stale: boolean;
-    publishedAt: number;
-};
-/** `globals`: present when the lookup asked for global items by name — the locale's rows of those collections,
- *  as `entries` returns them (document, model, stale; the raw fields may be empty), so a page is one call. */
-export type PublishedRoute = ({
-    kind: "page";
-    row: PublishedPageRow;
-} | {
-    kind: "entry";
-    row: PublishedEntryRow;
-}) & {
-    globals?: PublishedEntryRow[];
-};
-/** `model` and `stale` ride along so a tree read can rebuild what is behind before answering (spec 2026-10-07 §4). */
-export type PublishedTreeRow = Pick<PublishedPageRow, "id" | "parentId" | "sort" | "path" | "title" | "hasPage" | "linkFields" | "model" | "stale">;
-export type PublishedQuery = {
-    locale: string;
-    where?: Where;
-    order?: EntryOrder;
-    limit?: number;
-    parent?: string | null;
-    ids?: string[];
-};
-export type PublishedKey = {
-    kind: "page" | "entry";
-    id: string;
-    locale?: string;
-};
-export type PutOptions = {
-    keep?: boolean;
-};
-export interface PublishedStore {
-    /** Upsert by (id, locale). */
-    /** `keep` (a heal, a behind rebuild on read): an existing row keeps its publishedAt, a new row is dated now; without it
-     *  every row is dated now (a publish, `npx smoodly rebuild`). The static build's count reads publishedAt (spec 2026-10-09 §5). */
-    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
-    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
-    /** Every locale of the id when `locale` is absent. */
-    remove(keys: PublishedKey[]): Promise<void>;
-    /** The one-call lookup: a reachable page or entry at the address, else null. With `globals` (collection names of
-     *  global items), the locale's rows of those collections come along on the route (schema v9), still one call. */
-    byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
-    page(id: string, locale: string): Promise<PublishedPageRow | null>;
-    entry(id: string, locale: string): Promise<PublishedEntryRow | null>;
-    /** Filtered, ordered and limited over `fields`, in the store (SQL or the memory matcher). */
-    entries(collection: string, q: PublishedQuery): Promise<PublishedEntryRow[]>;
-    /** The light columns of every row in the locale, with the model and stale flag, in tree order (sort asc nulls last, published, id). */
-    tree(locale: string): Promise<PublishedTreeRow[]>;
-    markStale(keys: PublishedKey[]): Promise<void>;
-    /** The document stamp this space recorded as current (DESIGN §3): what `rebuild` last wrote, or the first
-     *  writer's; null until then. Only a reader at this stamp rewrites rows. */
-    recordedModel(): Promise<string | null>;
-    /** Record `model` as the space's current stamp (upsert by space). */
-    recordModel(model: string): Promise<void>;
-    /** Rows of both tables, and how many of them carry a stamp other than `model`: what `migrate --check` and Content health show. */
-    countBehind(model: string): Promise<{
-        behind: number;
-        total: number;
-    }>;
-    /** The latest published_at over the space's pages and entries (ms); null when nothing is published. The static build's watermark (spec 2026-10-09 static mode §5). */
-    newestPublishedAt(): Promise<number | null>;
-    /** Rows published strictly after `since` (ms), pages plus entries: the Deploy tile's "changes waiting". */
-    countPublishedAfter(since: number): Promise<number>;
-    /** The space's last Deploy press (schema v11, space_deploys); null until the first press. */
-    deployRequest(): Promise<{
-        at: number;
-        by: string | null;
-    } | null>;
-    requestDeploy(by: string | null, at?: number): Promise<void>;
-    /** When a row last went (an unpublish, a delete): a change the count of newer rows cannot see (same row, `removed_at`). */
-    lastRemovalAt(): Promise<number | null>;
-}
-export declare class MemoryPublishedStore implements PublishedStore {
-    private pages;
-    private entryRows;
-    private recorded;
-    recordedModel(): Promise<string | null>;
-    recordModel(model: string): Promise<void>;
-    private deploy;
-    newestPublishedAt(): Promise<number | null>;
-    countPublishedAfter(since: number): Promise<number>;
-    deployRequest(): Promise<{
-        at: number;
-        by: string | null;
-    } | null>;
-    requestDeploy(by: string | null, at?: number): Promise<void>;
-    countBehind(model: string): Promise<{
-        behind: number;
-        total: number;
-    }>;
-    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
-    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
-    private removedAt;
-    remove(keys: PublishedKey[]): Promise<void>;
-    lastRemovalAt(): Promise<number | null>;
-    byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
-    page(id: string, locale: string): Promise<PublishedPageRow | null>;
-    entry(id: string, locale: string): Promise<PublishedEntryRow | null>;
-    entries(collection: string, q: PublishedQuery): Promise<PublishedEntryRow[]>;
-    tree(locale: string): Promise<PublishedTreeRow[]>;
-    markStale(keys: PublishedKey[]): Promise<void>;
-}