smoodly 0.0.50 → 0.0.52

package/dist/entry-store.js

@@ -9,16 +9,8 @@
 // save rewrites the entry's outgoing edges over EVERY locale's live
 // field set. Reorder rewrites sort 1..N in one pass and NEVER touches
 // updatedAt — order is a property of the collection, not an edit.
-import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
-import { MemoryRefIndex } from "./ref-index.js";
-import { MemoryPathIndex } from "./path-index.js";
-import { anchorsFor } from "./anchors.js";
-import { groupRedirects } from "./store.js";
-import { assertFresh } from "./draft-token.js";
-import { globalEntryId } from "./global-id.js";
-import { DEFAULT_SPACE_ID } from "./sql-space.js";
-import { assertDepth, assertSupportedLocale, chainOf, entryPathRows, slugOf, unsupportedLocale, rewriteTargets, } from "./paths.js";
+import { slugOf, unsupportedLocale } from "./paths.js";
 /** The field types whose value is an array: a scalar `where` on one is
  *  containment, and any-of on one is refused by the site layer (both
  *  adapters read the text form of the whole array, never its elements). */
@@ -45,13 +37,6 @@ export function schemaOf(collections, name) {
 }
 /** A global item is a collection with exactly one entry (spec 2026-09-07). */
 export const isGlobalSchema = (schema) => schema.kind === "global";
-let counter = 0;
-const uid = (prefix) => `${prefix}-${++counter}-${Date.now().toString(36)}`;
-/** A version's saved time: wall-clock, but strictly increasing, so two saves in one
- *  millisecond still move the draft token (spec 2026-09-26 concurrency §1) the way
- *  Postgres's microsecond `now()` does. */
-let lastSavedAt = 0;
-const savedClock = () => (lastSavedAt = Math.max(Date.now(), lastSavedAt + 1));
 export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
 export const entryErrors = {
     notFound: (collection, id) => new Error(`smoodly: no entry "${id}" in "${collection}".`),
@@ -146,7 +131,7 @@ export function entryTitleIn(record, locale, schema) {
  * Sort comparator for one order rule; `seq` breaks ties by creation. A
  * declared order field is SHARED (collection() refuses a localized one),
  * so `e.fields[order.by]` reads the node. Nulls sort last in BOTH
- * directions (the Supabase adapter uses `nullsFirst: false` to match);
+ * directions (the SQLite list compiler sorts nulls last to match);
  * the creation tiebreak follows `direction` for non-manual orders.
  * Declared fields compare numerically when both values are numbers,
  * otherwise as strings via `localeCompare` — the same order Postgres
@@ -172,536 +157,3 @@ export function compareEntries(order, seq) {
         return d !== 0 ? d * dir : (seq(a) - seq(b)) * dir;
     };
 }
-/** Comparator for `query`: like compareEntries, but a declared field reads the
- *  merged snapshot, `updatedAt` the locale row's, and an absent, null or empty-string value
- *  sorts last in both directions; ties break by creation order (ascending). */
-export function compareSnapshots(order, locale, seq) {
-    return (a, b) => {
-        if (order === "manual") {
-            const d = (a.record.sort ?? Infinity) - (b.record.sort ?? Infinity);
-            return d !== 0 ? d : seq(a.record.id) - seq(b.record.id);
-        }
-        const dir = order.direction === "asc" ? 1 : -1;
-        const value = (r) => order.by === "createdAt" ? r.record.createdAt : order.by === "updatedAt" ? r.record.locales[locale]?.updatedAt : r.fields[order.by];
-        const empty = (v) => (v === "" ? undefined : v); // a cleared text or date is empty too
-        const va = empty(value(a)), vb = empty(value(b));
-        const tie = seq(a.record.id) - seq(b.record.id);
-        if (order.by === "createdAt")
-            return tie * dir; // the clock can tie within a millisecond; creation order cannot
-        if (va == null && vb == null)
-            return tie;
-        if (va == null)
-            return 1;
-        if (vb == null)
-            return -1;
-        const d = typeof va === "number" && typeof vb === "number" ? va - vb : String(va).localeCompare(String(vb));
-        return d !== 0 ? d * dir : tie;
-    };
-}
-export class MemoryEntryStore {
-    constructor(collections, 
-    // pass the SAME index to MemoryPageStore so cross-kind questions work
-    refs = new MemoryRefIndex(), options = {}) {
-        this.refs = refs;
-        this.entries = new Map();
-        this.versions = new Map();
-        /** Insertion order per version — `savedAt` alone can tie within a millisecond. */
-        this.versionSeq = new Map();
-        this.seq = 0;
-        this.order = new Map();
-        this.byId = (id) => this.entries.get(id);
-        this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
-        this.schemas = [...collections, ...(options.globals ?? [])];
-        // Alone, the store's own index reads its collections' addresses (spec 2026-09-29 anchored paths §2).
-        this.paths = options.paths ?? new MemoryPathIndex(anchorsFor({ locales: this.locales, collections }));
-        this.elements = options.elements;
-    }
-    schema(collection) {
-        return schemaOf(this.schemas, collection);
-    }
-    row(collection, id) {
-        const entry = this.entries.get(id);
-        return entry && entry.collection === collection ? entry : null;
-    }
-    must(collection, id) {
-        const entry = this.row(collection, id);
-        if (!entry)
-            throw entryErrors.notFound(collection, id);
-        return entry;
-    }
-    snapshot(entry) {
-        return structuredClone(entry);
-    }
-    subtree(entry) {
-        const out = [entry];
-        const walk = (parentId) => {
-            for (const e of this.entries.values())
-                if (e.parentId === parentId) {
-                    out.push(e);
-                    walk(e.id);
-                }
-        };
-        walk(entry.id);
-        return out;
-    }
-    /** An edit bumps the node and the edited row; `move` and `reorder` never call this. */
-    bump(entry, row, by) {
-        const now = Date.now();
-        entry.updatedAt = now > entry.updatedAt ? now : entry.updatedAt + 1;
-        if (row) {
-            row.updatedAt = entry.updatedAt;
-            row.updatedBy = by ?? null;
-        }
-    }
-    /** The draft rule (spec 2026-09-13 history §1) for every collection (spec 2026-09-14 §1):
-     *  the unpublished draft row is rewritten in place and a new one starts only when the
-     *  draft IS the published one. */
-    recordVersion(entry, locale) {
-        const row = entry.locales[locale];
-        const fields = entryFieldsIn(entry, locale);
-        const current = row.draftVersionId ? this.versions.get(row.draftVersionId) : undefined;
-        if (current && row.draftVersionId !== row.publishedVersionId) {
-            current.fields = fields;
-            current.savedAt = savedClock();
-            row.draftSavedAt = String(current.savedAt);
-            this.versionSeq.set(current.id, ++this.seq); // newest again
-            return;
-        }
-        const version = { id: uid("version"), entryId: entry.id, locale, fields, savedAt: savedClock() };
-        this.versions.set(version.id, version);
-        this.versionSeq.set(version.id, ++this.seq);
-        row.draftVersionId = version.id;
-        row.draftSavedAt = String(version.savedAt);
-    }
-    /** A published row from before every collection was versioned has no snapshot; give it
-     *  one from what is live BEFORE a write changes the fields, so the site keeps serving it
-     *  and the write lands in a new draft row (spec 2026-09-14 §1). */
-    ensureLiveSnapshot(entry, locale) {
-        const row = entry.locales[locale];
-        if (row.status !== "published" || row.publishedVersionId !== null)
-            return;
-        const version = { id: uid("version"), entryId: entry.id, locale, fields: entryFieldsIn(entry, locale), savedAt: savedClock() };
-        this.versions.set(version.id, version);
-        this.versionSeq.set(version.id, ++this.seq);
-        row.draftVersionId = version.id;
-        row.publishedVersionId = version.id;
-        row.draftSavedAt = String(version.savedAt);
-    }
-    dropVersions(entryId, locale) {
-        for (const [id, v] of this.versions) {
-            if (v.entryId === entryId && (locale === undefined || v.locale === locale)) {
-                this.versions.delete(id);
-                this.versionSeq.delete(id);
-            }
-        }
-    }
-    /** Every field set the site can render for this entry: each present
-     *  locale's live view, plus a published snapshot the draft has moved
-     *  past (still rendered by the published site). */
-    liveFieldSets(entry) {
-        const sets = [];
-        for (const [locale, row] of Object.entries(entry.locales)) {
-            sets.push(entryFieldsIn(entry, locale));
-            if (row.status === "published" && row.publishedVersionId && row.publishedVersionId !== row.draftVersionId) {
-                const snapshot = this.versions.get(row.publishedVersionId);
-                if (snapshot)
-                    sets.push(snapshot.fields);
-            }
-        }
-        return sets;
-    }
-    async writePaths(collection, nodes, redirect = true) {
-        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byId, collection));
-    }
-    writeRefs(entry) {
-        this.refs.rewrite({ sourceKind: "entry", sourceId: entry.id }, entryRefEdges(this.liveFieldSets(entry), this.schema(entry.collection), this.elements));
-    }
-    siblings(collection, parentId, except) {
-        return [...this.entries.values()]
-            .filter((e) => e.collection === collection && e.parentId === parentId && e.id !== except)
-            .sort(compareEntries("manual", (e) => this.order.get(e.id)));
-    }
-    /** The friendly pre-check (spec 2026-09-06 §11): a string slug must be
-     *  unique among the siblings PRESENT in that locale; null never
-     *  conflicts. The paths primary key remains the invariant. */
-    assertSiblingSlug(collection, parentId, locale, slug, except) {
-        if (slug === null)
-            return;
-        for (const e of this.siblings(collection, parentId, except)) {
-            if (e.locales[locale]?.slug === slug)
-                throw entryErrors.slugTaken(collection);
-        }
-    }
-    /** Same collection, within depth. Returns the parent (null at the root). */
-    assertParent(collection, parentId, subtreeHeight) {
-        if (parentId === null)
-            return null;
-        const parent = this.entries.get(parentId);
-        if (!parent)
-            throw entryErrors.notFound(collection, parentId);
-        if (parent.collection !== collection)
-            throw entryErrors.foreignParent();
-        assertDepth(chainOf(parent, this.byId).length + subtreeHeight, collectionDepth(this.schema(collection)), "the entry");
-        return parent;
-    }
-    /** The parent rule: a locale can only be added where the parent has it. */
-    assertParentHasLocale(parent, locale) {
-        if (parent && !parent.locales[locale])
-            throw entryErrors.parentNotInLocale(locale);
-    }
-    async create(collection, fields, options, by) {
-        const schema = this.schema(collection);
-        assertSupportedLocale(options.locale, this.locales);
-        const parentId = options.parentId ?? null;
-        if (isGlobalSchema(schema)) {
-            if ([...this.entries.values()].some((e) => e.collection === collection))
-                throw entryErrors.singleton(collection);
-            if (slugOf(fields) !== null)
-                throw entryErrors.noSlug(collection);
-        }
-        const parent = this.assertParent(collection, parentId, 1);
-        this.assertParentHasLocale(parent, options.locale);
-        const { shared, localized, slug } = splitFields(fields, schema);
-        this.assertSiblingSlug(collection, parentId, options.locale, slug);
-        const now = Date.now();
-        const entry = {
-            // A global item's id is derived, not minted (spec 2026-09-07 §10):
-            // the same uuid v5 the Supabase adapter computes, so self-host and
-            // cloud agree on the row a materialization would create.
-            id: isGlobalSchema(schema) ? await globalEntryId(DEFAULT_SPACE_ID, collection) : uid("entry"),
-            collection, parentId, fields: shared,
-            locales: {
-                [options.locale]: {
-                    slug, status: "draft", fields: localized, draftVersionId: null, draftSavedAt: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
-                },
-            },
-            sort: null, createdAt: now, updatedAt: now,
-        };
-        this.recordVersion(entry, options.locale);
-        this.entries.set(entry.id, entry);
-        this.order.set(entry.id, ++this.seq);
-        try {
-            await this.writePaths(collection, [entry]);
-        }
-        catch (e) {
-            this.entries.delete(entry.id);
-            this.order.delete(entry.id);
-            this.dropVersions(entry.id);
-            throw e;
-        }
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async get(collection, id) {
-        const entry = this.row(collection, id);
-        return entry ? this.snapshot(entry) : null;
-    }
-    async list(collection, options) {
-        const schema = this.schema(collection);
-        let rows = [...this.entries.values()].filter((e) => e.collection === collection);
-        if (options?.status || options?.locale !== undefined) {
-            const locale = options.locale ?? this.locales.default;
-            rows = rows.filter((e) => {
-                const row = e.locales[locale];
-                return row !== undefined && (!options.status || row.status === options.status);
-            });
-        }
-        if (options?.parent !== undefined)
-            rows = rows.filter((e) => e.parentId === options.parent);
-        if (options?.where)
-            rows = rows.filter((e) => matchesWhere(e.fields, options.where));
-        rows.sort(compareEntries(options?.order ?? collectionOrder(schema), (e) => this.order.get(e.id)));
-        if (typeof options?.limit === "number")
-            rows = rows.slice(0, options.limit);
-        return rows.map((e) => this.snapshot(e));
-    }
-    async query(collection, q) {
-        const schema = this.schema(collection);
-        const wanted = q.ids ? new Set(q.ids) : null;
-        const rows = [];
-        for (const e of this.entries.values()) {
-            if (e.collection !== collection)
-                continue;
-            if (wanted && !wanted.has(e.id))
-                continue;
-            if (q.parent !== undefined && e.parentId !== q.parent)
-                continue;
-            const row = e.locales[q.locale];
-            if (!row || (!q.draft && row.status !== "published"))
-                continue;
-            const snapshot = !q.draft && row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
-            const fields = snapshot ? structuredClone(snapshot.fields) : entryFieldsIn(e, q.locale);
-            if (q.where && !matchesWhere(fields, q.where))
-                continue;
-            rows.push({ record: this.snapshot(e), fields });
-        }
-        rows.sort(compareSnapshots(q.order ?? collectionOrder(schema), q.locale, (id) => this.order.get(id)));
-        return typeof q.limit === "number" ? rows.slice(0, q.limit) : rows;
-    }
-    async getMany(collection, ids, locale, options) {
-        this.schema(collection);
-        const out = {};
-        for (const id of ids) {
-            const entry = this.row(collection, id);
-            const row = entry?.locales[locale];
-            if (!entry || !row)
-                continue;
-            if (options?.status) {
-                if (row.status !== options.status)
-                    continue;
-                // A versioned collection serves what was published, not the live row.
-                const snapshot = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
-                out[id] = snapshot ? structuredClone(snapshot.fields) : entryFieldsIn(entry, locale);
-            }
-            else {
-                out[id] = entryFieldsIn(entry, locale);
-            }
-        }
-        return out;
-    }
-    async update(collection, id, locale, fields, by, expected, options) {
-        const schema = this.schema(collection);
-        const entry = this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        assertFresh(row, expected);
-        this.ensureLiveSnapshot(entry, locale);
-        const { shared, localized, slug } = splitFields(fields, schema);
-        if (isGlobalSchema(schema) && slug !== null)
-            throw entryErrors.noSlug(collection);
-        this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
-        const before = { fields: entry.fields, row: { ...row } };
-        entry.fields = keepLocalizedShared(before.fields, shared, schema);
-        row.fields = localized;
-        row.slug = slug;
-        try {
-            await this.writePaths(collection, this.subtree(entry), options?.redirect ?? true);
-        }
-        catch (e) {
-            entry.fields = before.fields;
-            Object.assign(row, before.row);
-            throw e;
-        }
-        this.recordVersion(entry, locale);
-        this.bump(entry, row, by);
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async setStatus(collection, id, locale, status, by, expected) {
-        const entry = this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        if (status === "published") {
-            assertFresh(row, expected);
-            // Publish points at the current draft; a row always has one after its first write, but never trust that from here.
-            if (!row.draftVersionId)
-                this.recordVersion(entry, locale);
-            row.publishedVersionId = row.draftVersionId;
-        }
-        // Unpublish keeps the pointer for a later republish (spec §2).
-        row.status = status;
-        this.bump(entry, row, by);
-        this.writeRefs(entry); // the published snapshot just became, or stopped being, a live set
-        return this.snapshot(entry);
-    }
-    async discardDraft(collection, id, locale, by, expected) {
-        const schema = this.schema(collection);
-        const entry = this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        assertFresh(row, expected);
-        const snapshot = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
-        if (!snapshot)
-            throw entryErrors.nothingPublished(collection, id, locale);
-        const { shared, localized } = splitFields(snapshot.fields, schema);
-        entry.fields = keepLocalizedShared(entry.fields, shared, schema);
-        row.fields = localized;
-        const abandoned = row.draftVersionId;
-        row.draftVersionId = row.publishedVersionId;
-        row.draftSavedAt = String(snapshot.savedAt);
-        if (abandoned && abandoned !== row.publishedVersionId) {
-            this.versions.delete(abandoned);
-            this.versionSeq.delete(abandoned);
-        }
-        this.bump(entry, row, by);
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async addLocale(collection, id, locale, options, by) {
-        assertSupportedLocale(locale, this.locales);
-        const entry = this.must(collection, id);
-        // The source is read FIRST: "copy from a locale that isn't there" is
-        // the more specific complaint, even when the target locale also exists.
-        const source = entryLocaleRow(entry, options.from);
-        if (entry.locales[locale])
-            throw entryErrors.alreadyInLocale(id, locale);
-        const parent = entry.parentId === null ? null : (this.entries.get(entry.parentId) ?? null);
-        this.assertParentHasLocale(parent, locale);
-        this.assertSiblingSlug(collection, entry.parentId, locale, source.slug, id);
-        const now = Date.now();
-        entry.locales[locale] = {
-            slug: source.slug, status: "draft", fields: structuredClone(source.fields),
-            draftVersionId: null, draftSavedAt: null, publishedVersionId: null, updatedAt: now, updatedBy: by ?? null,
-        };
-        this.recordVersion(entry, locale);
-        // Only this node's rows change: a child cannot have a locale its parent lacked.
-        try {
-            await this.writePaths(collection, [entry]);
-        }
-        catch (e) {
-            delete entry.locales[locale];
-            this.dropVersions(id, locale);
-            throw e;
-        }
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async removeLocale(collection, id, locale) {
-        const schema = this.schema(collection);
-        if (isGlobalSchema(schema))
-            throw entryErrors.everyLocale(collection);
-        const entry = this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        if (Object.keys(entry.locales).length === 1)
-            throw entryErrors.lastLocale(id);
-        const blockers = [...this.entries.values()]
-            .filter((e) => e.parentId === id && e.locales[locale] !== undefined)
-            .map((e) => entryTitleIn(e, locale, schema));
-        if (blockers.length > 0)
-            throw entryErrors.localeInUse(locale, blockers);
-        delete entry.locales[locale];
-        try {
-            await this.writePaths(collection, [entry], false);
-        }
-        catch (e) {
-            entry.locales[locale] = row;
-            throw e;
-        }
-        this.dropVersions(id, locale);
-        this.bump(entry);
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async scanEntries() {
-        return [...this.entries.values()].map((entry) => ({
-            record: this.snapshot(entry),
-            live: Object.fromEntries(Object.entries(entry.locales).map(([l, row]) => {
-                if (row.status !== "published")
-                    return [l, null];
-                // A legacy published row without a snapshot serves its live row (spec 2026-09-14 §1).
-                const snap = row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
-                return [l, snap ? structuredClone(snap.fields) : entryFieldsIn(entry, l)];
-            })),
-        }));
-    }
-    async listVersions(collection, id, locale) {
-        this.must(collection, id);
-        return [...this.versions.values()]
-            .filter((v) => v.entryId === id && v.locale === locale)
-            .sort((a, b) => b.savedAt - a.savedAt || this.versionSeq.get(b.id) - this.versionSeq.get(a.id))
-            .map((v) => structuredClone(v));
-    }
-    async restore(collection, id, locale, versionId, by, expected) {
-        const schema = this.schema(collection);
-        const entry = this.must(collection, id);
-        const row = entryLocaleRow(entry, locale);
-        const version = this.versions.get(versionId);
-        if (!version || version.entryId !== id || version.locale !== locale)
-            throw entryErrors.foreignVersion(collection, id, locale, versionId);
-        assertFresh(row, expected);
-        if (versionId === row.publishedVersionId)
-            return this.discardDraft(collection, id, locale, by, expected);
-        const { shared, localized } = splitFields(version.fields, schema);
-        entry.fields = keepLocalizedShared(entry.fields, shared, schema);
-        row.fields = localized; // the slug is the row's own and never versioned
-        this.recordVersion(entry, locale);
-        this.bump(entry, row, by);
-        this.writeRefs(entry);
-        return this.snapshot(entry);
-    }
-    async getVersion(collection, versionId) {
-        this.schema(collection);
-        const v = this.versions.get(versionId);
-        return v ? structuredClone(v) : null;
-    }
-    async move(collection, id, to, options) {
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "it has no tree position");
-        const entry = this.must(collection, id);
-        const subtree = this.subtree(entry);
-        if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
-            throw entryErrors.cycle();
-        const height = Math.max(...subtree.map((e) => chainOf(e, this.byId).length)) - chainOf(entry, this.byId).length + 1;
-        const parent = this.assertParent(collection, to.parentId, height);
-        // The destination must have every locale the entry has, or a chain breaks there.
-        if (parent)
-            for (const locale of Object.keys(entry.locales))
-                if (!parent.locales[locale])
-                    throw entryErrors.moveLocales(locale);
-        if (to.parentId !== entry.parentId) {
-            for (const [locale, row] of Object.entries(entry.locales))
-                this.assertSiblingSlug(collection, to.parentId, locale, row.slug, id);
-        }
-        const before = { parentId: entry.parentId, sort: entry.sort };
-        entry.parentId = to.parentId;
-        const siblings = this.siblings(collection, to.parentId, id);
-        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
-        siblings.splice(index, 0, entry);
-        const previous = new Map(siblings.map((s) => [s.id, s.sort]));
-        siblings.forEach((s, i) => (s.sort = i + 1));
-        try {
-            await this.writePaths(collection, subtree, options?.redirect ?? true);
-        }
-        catch (e) {
-            Object.assign(entry, before);
-            for (const s of siblings)
-                s.sort = previous.get(s.id) ?? null;
-            throw e;
-        }
-        return this.snapshot(entry);
-    }
-    async delete(collection, id) {
-        const entry = this.row(collection, id);
-        if (!entry)
-            return;
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "remove the registration to remove it");
-        if ([...this.entries.values()].some((e) => e.parentId === id))
-            throw entryErrors.hasChildren(collection, id);
-        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.`);
-        }
-        await this.paths.remove([{ kind: "entry", id }]);
-        this.entries.delete(id);
-        this.order.delete(id);
-        this.dropVersions(id);
-        this.refs.remove({ sourceKind: "entry", sourceId: id });
-    }
-    async reorder(collection, orderedIds) {
-        if (isGlobalSchema(this.schema(collection)))
-            throw entryErrors.owned(collection, "it has no order");
-        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);
-    }
-    resolvePath(locale, path) {
-        return this.paths.resolve(locale, path);
-    }
-    pathsIn(collection, ids, locale) {
-        this.schema(collection);
-        return this.paths.livePathsIn("entry", ids, locale);
-    }
-    pathsOf(collection, id) {
-        return this.row(collection, id) ? this.paths.pathsOf({ kind: "entry", id }) : Promise.resolve({});
-    }
-    async redirectsOf(collection, id) {
-        this.schema(collection);
-        return groupRedirects(await this.paths.redirectsOf({ kind: "entry", id }));
-    }
-}

package/dist/env.d.ts

@@ -1,20 +1,27 @@
-import { readCurrentSpace } from "./current-space.ts";
 export type SmoodlyEnv = {
-    /** The content project. */
-    url: string;
-    /** Server-only: the service-role key (self-host) or the environment's write key (cloud). */
+    /** Server-only: the space's secret key (sk_…), minted by Smoodly's API. */
     secretKey: string;
-    /** What a browser may hold for the content project: anon/publishable key, or the cloud's per-environment key. It reads no content (sign-in and presence only). "" on a live site that runs without the admin. */
+    /** The space's publishable key (pk_…), what a browser may hold: it reads published content only. "" when unset. */
     publishableKey: string;
-    /** Where editors sign in. Defaults to `url`. */
-    authUrl: string;
-    /** That project's publishable key. Defaults to `publishableKey`. */
-    authKey: string;
+    /** Smoodly's API, without a trailing slash: the site reads there and the admin posts its operations there
+     *  (spec 2026-10-14 §1). */
+    apiUrl: string;
+    /** The space the site's keys belong to (SMOODLY_SPACE_ID). */
+    spaceId: string;
+};
+/** Who asks: a site reading over the API, or its admin. */
+export type SmoodlyEnvNeed = "site" | "admin";
+/** Smoodly's hosted API; SMOODLY_API_URL is set only for another address (the repo's loop, a staging service). */
+export declare const DEFAULT_API_URL = "https://api.smoodly.io";
+/** The live site and its admin read over the API with its address, the space and the secret key (spec 2026-10-16 the
+ *  control plane §5). A key in the wrong variable or of no known form is named here, not by a failed read later. */
+export declare function resolveSmoodlyEnv(env: Record<string, string | undefined>, need?: SmoodlyEnvNeed): SmoodlyEnv;
+/** What the API client is built from (createSmoodlyApi): the site's env, the secret key as the key. */
+export declare function apiEnv(env?: Record<string, string | undefined>): {
+    apiUrl: string;
+    spaceId: string;
+    key: string;
 };
-/** The live site reads with the URL and the secret key; the admin and presence also need the
- *  publishable key, so their callers pass "admin" (spec 2026-09-30 tester findings §4). A key
- *  in the wrong variable or of no known form is named here, not by a failed read later. */
-export declare function resolveSmoodlyEnv(env: Record<string, string | undefined>, need?: "site" | "admin"): SmoodlyEnv;
 /** The site's own address for the root layout's `metadataBase`, so canonical, hreflang and social
  *  image links are absolute. A value without a scheme is named here, not by a bare "Invalid URL" on
  *  every page; an unset one falls back to localhost and warns once in production, where it would
@@ -22,13 +29,13 @@ export declare function resolveSmoodlyEnv(env: Record<string, string | undefined
 export declare function siteUrl(env?: Record<string, string | undefined>): URL;
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
-export declare const smoodlyEnv: (need?: "site" | "admin") => SmoodlyEnv;
-/** What the browser needs to join the admin's presence channel: the content project's URL, publishable key and space, public values only — never for content reads (spec 2026-09-29 content API contract §8). */
+export declare const smoodlyEnv: (need?: SmoodlyEnvNeed) => SmoodlyEnv;
+/** What the browser needs to open the admin's presence socket: Smoodly's API and the space, public values only
+ *  (spec 2026-10-15 the space object §6). The socket opens with a one-time ticket the service signs from the editor's
+ *  pass (spec 2026-10-16 sign-in and the dashboard §3). */
 export type PresenceConfig = {
-    url: string;
-    key: string;
+    apiUrl: string;
     spaceId: string;
 };
-/** The presence config, with the space the database says the secret key acts in —
- *  asked, never read out of the key, so it cannot disagree with where rows land. */
-export declare function presenceConfig(env: SmoodlyEnv, db?: Parameters<typeof readCurrentSpace>[0]): Promise<PresenceConfig>;
+/** The presence config from the env: no lookup, the space is the site's own. */
+export declare function presenceConfig(env: SmoodlyEnv): PresenceConfig;