smoodly 0.0.51 → 0.0.53

package/dist/store.js

@@ -1,7 +1,7 @@
 // The page persistence contract. Writes always go through this API —
 // never raw table access — so validation, versioning and publish hooks
-// can't be bypassed (DESIGN.md §1). MemoryPageStore is the reference
-// implementation and the contract-test subject; the Supabase adapter
+// can't be bypassed (DESIGN.md §1). MemoryPageStore (packages/service/src/stores)
+// is the reference implementation and the contract-test subject; the space object's SQLite store
 // implements the same interface over pages/page_locales/page_versions.
 //
 // The model (spec 2026-09-06): a page is ONE node with ONE row per
@@ -12,10 +12,7 @@
 import { ASSET_COLLECTION } from "./media.js";
 import { collectTreeRefs } from "./refs.js";
 import { customToolset, withCustomSchema } from "./custom/index.js";
-import { MemoryPathIndex } from "./path-index.js";
-import { assertFresh } from "./draft-token.js";
-import { SCHEMA_VERSION } from "./schema-version.js";
-import { assertDepth, assertSegment, assertSupportedLocale, chainOf, isHomeNode, pagePathRows, unsupportedLocale, rewriteTargets, } from "./paths.js";
+import { unsupportedLocale, } from "./paths.js";
 export const DEFAULT_LOCALES = { default: "en", supported: ["en"] };
 /** The section list every adapter walks refs with: the registered ones plus the custom section's schema (spec 2026-09-14 §6). */
 /** Group an index's redirect rows by locale, paths sorted. */
@@ -65,7 +62,6 @@ export const pageErrors = {
     fixedTaken: (key) => new Error(`smoodly: a page owned by "${key}" already exists.`),
     fixedAtRoot: () => new Error("smoodly: a code-owned page is a root record."),
 };
-export { assertSupportedLocale } from "./paths.js";
 /** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
 export function localeRow(page, locale) {
     const row = page.locales[locale];
@@ -107,485 +103,3 @@ export async function assertPublishable(label, tree, sections, entries, locale)
         throw new Error(`smoodly: cannot publish "${label}" — it references entries that are not published: ${offenders.join(", ")}.`);
     }
 }
-let counter = 0;
-const uid = () => `id-${++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));
-/** The row's audit pair: every write that touches a locale row sets both (spec 2026-09-13 history §2). */
-function touchRow(row, by) {
-    row.updatedAt = Date.now();
-    row.updatedBy = by ?? null;
-}
-export class MemoryPageStore {
-    constructor(options = {}) {
-        this.options = options;
-        this.pages = new Map();
-        this.versions = new Map();
-        /** Append-only creation-order tie-break; `size + 1` stays fresh only because entries are never deleted. */
-        this.seq = new Map();
-        this.byId = (id) => this.pages.get(id);
-        this.options = { ...options, sections: refSections(options) };
-        this.opts = pathOptions(options);
-        // Alone, the store's own index reads the addresses it was given (spec 2026-09-29 anchored paths §2).
-        this.paths = options.paths ?? new MemoryPathIndex(storeAnchors(options));
-    }
-    must(id) {
-        const page = this.pages.get(id);
-        if (!page)
-            throw pageErrors.notFound(id);
-        return page;
-    }
-    isHome(page) {
-        return isHomeNode(page, this.opts);
-    }
-    snapshot(page) {
-        return { ...page, locales: structuredClone(page.locales) };
-    }
-    children(id) {
-        return [...this.pages.values()].filter((p) => p.parentId === id);
-    }
-    hasChildren(id) {
-        return this.children(id).length > 0;
-    }
-    siblings(parentId, except) {
-        return [...this.pages.values()]
-            .filter((p) => p.parentId === parentId && p.id !== except)
-            // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
-            .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id));
-    }
-    /** 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). */
-    assertSlugFree(parentId, locale, slug, except) {
-        if (this.siblings(parentId, except).some((p) => !p.fixed && p.locales[locale]?.slug === slug))
-            throw pageErrors.slugTaken(slug);
-    }
-    subtree(id) {
-        const out = [];
-        const walk = (parentId) => {
-            for (const p of this.pages.values())
-                if (p.parentId === parentId) {
-                    out.push(p);
-                    walk(p.id);
-                }
-        };
-        const root = this.must(id);
-        out.push(root);
-        walk(id);
-        return out;
-    }
-    async writePaths(nodes, redirect = true) {
-        await this.paths.rewrite(rewriteTargets("page", nodes, redirect), pagePathRows(nodes, this.byId, this.opts));
-    }
-    /** Every locale's draft and published trees, deduped by version id. */
-    liveTrees(page) {
-        const ids = new Set();
-        for (const row of Object.values(page.locales)) {
-            if (row.draftVersionId)
-                ids.add(row.draftVersionId);
-            if (row.publishedVersionId)
-                ids.add(row.publishedVersionId);
-        }
-        const trees = [];
-        for (const id of ids) {
-            const tree = this.versions.get(id)?.tree;
-            if (tree)
-                trees.push(tree);
-        }
-        return trees;
-    }
-    writeRefs(page) {
-        const { sections, elements, refs } = this.options;
-        if (!sections || !refs)
-            return;
-        refs.rewrite({ sourceKind: "page", sourceId: page.id }, pageRefEdges(this.liveTrees(page), sections, elements));
-    }
-    newVersion(pageId, locale, tree) {
-        const version = { id: uid(), pageId, locale, tree: structuredClone(tree), savedAt: savedClock() };
-        this.versions.set(version.id, version);
-        return version;
-    }
-    /** 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. */
-    writeDraftVersion(page, locale, tree, by) {
-        const row = localeRow(page, locale);
-        const current = row.draftVersionId ? this.versions.get(row.draftVersionId) : undefined;
-        let version;
-        if (current && row.draftVersionId !== row.publishedVersionId) {
-            current.tree = structuredClone(tree);
-            current.savedAt = savedClock();
-            row.draftSavedAt = String(current.savedAt);
-            version = current;
-        }
-        else {
-            version = this.newVersion(page.id, locale, tree);
-            row.draftVersionId = version.id;
-            row.draftSavedAt = String(version.savedAt);
-        }
-        touchRow(row, by);
-        return version;
-    }
-    dropVersions(pageId, locale) {
-        for (const [vid, v] of this.versions) {
-            if (v.pageId === pageId && (locale === undefined || v.locale === locale))
-                this.versions.delete(vid);
-        }
-    }
-    async createPage(input, by) {
-        assertSupportedLocale(input.locale, this.opts.locales);
-        assertSegment(input.slug, "page slug");
-        const parentId = input.parentId ?? null;
-        if (input.fixed !== undefined) {
-            if (parentId !== null)
-                throw pageErrors.fixedAtRoot();
-            if ([...this.pages.values()].some((p) => p.fixed === input.fixed))
-                throw pageErrors.fixedTaken(input.fixed);
-        }
-        if (parentId !== null) {
-            const parent = this.must(parentId);
-            if (this.isHome(parent))
-                throw pageErrors.homeChildren();
-            if (!parent.locales[input.locale])
-                throw pageErrors.parentNotInLocale(input.locale);
-            assertDepth(chainOf(parent, this.byId).length + 1, this.opts.depth, "the page");
-        }
-        if (input.fixed === undefined)
-            this.assertSlugFree(parentId, input.locale, input.slug);
-        const id = uid();
-        const version = input.template === null ? null : this.newVersion(id, input.locale, { zones: {} });
-        const page = {
-            id,
-            parentId,
-            template: input.template,
-            // An ordering hint, not a unique key: duplicates are possible after
-            // moves/deletes, and the creation-order tie-break settles them.
-            sort: this.siblings(parentId).length + 1,
-            fixed: input.fixed ?? null,
-            locales: {
-                [input.locale]: {
-                    slug: input.slug,
-                    title: input.title ?? input.slug,
-                    status: "draft",
-                    draftVersionId: version?.id ?? null,
-                    draftSavedAt: version ? String(version.savedAt) : null,
-                    publishedVersionId: null,
-                    updatedAt: Date.now(),
-                    updatedBy: by ?? null,
-                },
-            },
-        };
-        this.pages.set(id, page);
-        this.seq.set(id, this.seq.size + 1);
-        try {
-            await this.writePaths([page]);
-        }
-        catch (e) {
-            this.pages.delete(id);
-            if (version)
-                this.versions.delete(version.id);
-            throw e;
-        }
-        return this.snapshot(page);
-    }
-    async getPage(id) {
-        const page = this.pages.get(id);
-        return page ? this.snapshot(page) : null;
-    }
-    async scanTrees() {
-        const tree = (id) => (id ? structuredClone(this.versions.get(id)?.tree ?? null) : null);
-        return (await this.listPages()).map((record) => ({
-            record,
-            draft: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [l, tree(row.draftVersionId)])),
-            live: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [l, tree(row.publishedVersionId)])),
-        }));
-    }
-    async listPages() {
-        return [...this.pages.values()]
-            // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
-            .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id))
-            .map((p) => this.snapshot(p));
-    }
-    resolvePath(locale, path) {
-        return this.paths.resolve(locale, path);
-    }
-    schemaVersion() {
-        return Promise.resolve(SCHEMA_VERSION);
-    }
-    pathsOf(id) {
-        return this.paths.pathsOf({ kind: "page", id });
-    }
-    targetPaths(target) { return this.paths.pathsOf(target); }
-    async redirectsOf(id) { return groupRedirects(await this.paths.redirectsOf({ kind: "page", id })); }
-    listLive(locale) { return this.paths.listLive(locale); }
-    listRedirects(locale) { return this.paths.listRedirects(locale); }
-    addRedirect(row) { return this.paths.addRedirect(row); }
-    removeRedirect(locale, path) { return this.paths.removeRedirect(locale, path); }
-    async addLocale(id, locale, options, by) {
-        assertSupportedLocale(locale, this.opts.locales);
-        const page = this.must(id);
-        if (page.locales[locale])
-            throw pageErrors.alreadyInLocale(id, locale);
-        const source = localeRow(page, options.from);
-        const slug = options.slug ?? source.slug;
-        if (options.slug !== undefined)
-            assertSegment(slug, `page slug (${locale})`);
-        if (page.parentId !== null && !this.must(page.parentId).locales[locale])
-            throw pageErrors.parentNotInLocale(locale);
-        if (!page.fixed)
-            this.assertSlugFree(page.parentId, locale, slug, id);
-        // The SOURCE'S DRAFT is the copy: what the editor sees on screen when
-        // they add the locale (spec §3). A folder has no tree to copy.
-        const version = page.template === null
-            ? null
-            : this.newVersion(id, locale, (source.draftVersionId && this.versions.get(source.draftVersionId)?.tree) || { zones: {} });
-        page.locales[locale] = {
-            slug,
-            title: options.title ?? source.title,
-            status: "draft",
-            draftVersionId: version?.id ?? null,
-            draftSavedAt: version ? String(version.savedAt) : null,
-            publishedVersionId: null,
-            updatedAt: Date.now(),
-            updatedBy: by ?? null,
-        };
-        try {
-            await this.writePaths([page]);
-        }
-        catch (e) {
-            delete page.locales[locale];
-            if (version)
-                this.versions.delete(version.id);
-            throw e;
-        }
-        this.writeRefs(page);
-        return this.snapshot(page);
-    }
-    async removeLocale(id, locale) {
-        const page = this.must(id);
-        const removed = localeRow(page, locale);
-        if (Object.keys(page.locales).length === 1)
-            throw pageErrors.lastLocale(id);
-        // Under the parent rule only direct children can hold the locale, but
-        // the walk is cheap and the message must name every blocker.
-        const blockers = this.subtree(id).filter((n) => n.id !== id && n.locales[locale]);
-        if (blockers.length > 0)
-            throw pageErrors.localeInUse(locale, blockers.map((b) => b.locales[locale].title));
-        delete page.locales[locale];
-        try {
-            await this.writePaths([page], false);
-        }
-        catch (e) {
-            page.locales[locale] = removed;
-            throw e;
-        }
-        this.dropVersions(id, locale);
-        this.writeRefs(page);
-        return this.snapshot(page);
-    }
-    async rename(id, patch, by, options) {
-        const page = this.must(id);
-        const row = localeRow(page, patch.locale);
-        if (patch.slug !== undefined)
-            assertSegment(patch.slug, `page slug (${patch.locale})`);
-        // A rename that turns this node INTO the home node (root, default-locale
-        // slug === homePageSlug) is subject to the same invariant as createPage:
-        // the home page cannot have child pages.
-        if (patch.locale === this.opts.locales.default &&
-            patch.slug !== undefined &&
-            page.parentId === null &&
-            patch.slug === this.opts.homePageSlug &&
-            this.hasChildren(id)) {
-            throw pageErrors.homeChildren();
-        }
-        if (patch.slug !== undefined && !page.fixed)
-            this.assertSlugFree(page.parentId, patch.locale, patch.slug, id);
-        const before = { ...row };
-        if (patch.slug !== undefined)
-            row.slug = patch.slug;
-        if (patch.title !== undefined)
-            row.title = patch.title;
-        try {
-            await this.writePaths(this.subtree(id), options?.redirect ?? true);
-        }
-        catch (e) {
-            Object.assign(row, before);
-            throw e;
-        }
-        touchRow(row, by);
-        return this.snapshot(page);
-    }
-    async move(id, to, options) {
-        const page = this.must(id);
-        if (page.fixed && to.parentId !== null)
-            throw pageErrors.fixedAtRoot();
-        if (to.parentId !== null) {
-            const parent = this.must(to.parentId);
-            if (to.parentId === id || chainOf(parent, this.byId).some((n) => n.id === id))
-                throw pageErrors.cycle();
-            if (this.isHome(parent))
-                throw pageErrors.homeChildren();
-            // The parent rule, on the move: every locale the page has must be
-            // present at the destination, or its chain would break there.
-            for (const locale of Object.keys(page.locales))
-                if (!parent.locales[locale])
-                    throw pageErrors.moveLocales(locale);
-            const subtreeDepth = Math.max(...this.subtree(id).map((n) => chainOf(n, this.byId).length)) - chainOf(page, this.byId).length + 1;
-            assertDepth(chainOf(parent, this.byId).length + subtreeDepth, this.opts.depth, "the page");
-        }
-        else if (page.locales[this.opts.locales.default]?.slug === this.opts.homePageSlug && this.hasChildren(id)) {
-            // Moving a home-slugged node TO the root is the mirror case of the
-            // rename guard above: it would make it the home node while it still
-            // has children.
-            throw pageErrors.homeChildren();
-        }
-        if (to.parentId !== page.parentId) {
-            for (const [locale, row] of Object.entries(page.locales))
-                this.assertSlugFree(to.parentId, locale, row.slug, id);
-        }
-        const before = { parentId: page.parentId, sort: page.sort };
-        page.parentId = to.parentId;
-        const siblings = this.siblings(to.parentId, id);
-        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
-        siblings.splice(index, 0, page);
-        const previousSort = new Map(siblings.map((s) => [s.id, s.sort]));
-        siblings.forEach((s, i) => (s.sort = i + 1));
-        try {
-            await this.writePaths(this.subtree(id), options?.redirect ?? true);
-        }
-        catch (e) {
-            Object.assign(page, before);
-            for (const s of siblings)
-                s.sort = previousSort.get(s.id) ?? null;
-            throw e;
-        }
-        return this.snapshot(page);
-    }
-    async setTemplate(id, template, by) {
-        const page = this.must(id);
-        if (page.template !== null)
-            throw pageErrors.hasTemplate(id);
-        page.template = template;
-        for (const [locale, row] of Object.entries(page.locales)) {
-            const version = this.newVersion(id, locale, { zones: {} });
-            row.draftVersionId = version.id;
-            row.draftSavedAt = String(version.savedAt);
-            touchRow(row, by);
-        }
-        return this.snapshot(page);
-    }
-    async saveDraft(id, locale, tree, by, expected) {
-        const page = this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        assertFresh(localeRow(page, locale), expected);
-        const version = this.writeDraftVersion(page, locale, tree, by);
-        this.writeRefs(page);
-        return { ...version, tree: structuredClone(version.tree) };
-    }
-    async publish(id, locale, by, expected) {
-        const page = this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        const row = localeRow(page, locale);
-        assertFresh(row, expected);
-        if (!row.draftVersionId)
-            throw pageErrors.folder(id);
-        const { sections, entries } = this.options;
-        const draft = this.versions.get(row.draftVersionId)?.tree ?? { zones: {} };
-        if (sections && entries)
-            await assertPublishable(row.slug, draft, sections, entries, locale);
-        row.publishedVersionId = row.draftVersionId;
-        row.status = "published";
-        touchRow(row, by);
-        this.writeRefs(page);
-        return this.snapshot(page);
-    }
-    async discardDraft(id, locale, by, expected) {
-        const page = this.must(id);
-        const row = localeRow(page, locale);
-        assertFresh(row, expected);
-        if (!row.publishedVersionId)
-            throw pageErrors.nothingPublished(id, locale);
-        const abandoned = row.draftVersionId;
-        row.draftVersionId = row.publishedVersionId;
-        row.draftSavedAt = String(this.versions.get(row.publishedVersionId).savedAt);
-        if (abandoned && abandoned !== row.publishedVersionId)
-            this.versions.delete(abandoned); // never shown as a stray draft
-        touchRow(row, by);
-        this.writeRefs(page); // the refs union (draft ∪ published) just shrank to one tree
-        return this.snapshot(page);
-    }
-    async unpublish(id, locale, by) {
-        const page = this.must(id);
-        const row = localeRow(page, locale);
-        row.status = "draft";
-        touchRow(row, by);
-        this.writeRefs(page);
-        return this.snapshot(page);
-    }
-    async restore(id, locale, versionId, by, expected) {
-        const page = this.must(id);
-        if (page.template === null)
-            throw pageErrors.folder(id);
-        const row = localeRow(page, locale);
-        const version = this.versions.get(versionId);
-        if (!version || version.pageId !== id || version.locale !== locale)
-            throw pageErrors.foreignVersion(id, locale, versionId);
-        // The memory store is single-threaded: the read-side check IS the atomic check.
-        assertFresh(row, expected);
-        if (versionId === row.publishedVersionId)
-            return this.discardDraft(id, locale, by, expected);
-        this.writeDraftVersion(page, locale, version.tree, by);
-        this.writeRefs(page);
-        return this.snapshot(page);
-    }
-    async getVersion(versionId) {
-        const v = this.versions.get(versionId);
-        return v ? { ...v, tree: structuredClone(v.tree) } : null;
-    }
-    async getDraftTree(id, locale) {
-        const row = this.pages.get(id)?.locales[locale];
-        if (!row?.draftVersionId)
-            return null;
-        return structuredClone(this.versions.get(row.draftVersionId)?.tree ?? null);
-    }
-    async fieldsOf(versionIds) {
-        const out = {};
-        for (const id of versionIds) {
-            const v = this.versions.get(id);
-            if (v)
-                out[id] = structuredClone(v.tree.fields ?? {});
-        }
-        return out;
-    }
-    async getPublishedTree(id, locale) {
-        const row = this.pages.get(id)?.locales[locale];
-        if (!row?.publishedVersionId)
-            return null;
-        return structuredClone(this.versions.get(row.publishedVersionId)?.tree ?? null);
-    }
-    async listVersions(id, locale) {
-        return [...this.versions.values()]
-            .filter((v) => v.pageId === id && v.locale === locale)
-            .sort((a, b) => b.savedAt - a.savedAt || b.id.localeCompare(a.id))
-            .map((v) => ({ ...v, tree: structuredClone(v.tree) }));
-    }
-    async deletePage(id) {
-        const page = this.pages.get(id);
-        if (!page)
-            return;
-        if (this.hasChildren(id))
-            throw pageErrors.hasChildren(id);
-        // The index removal goes first: in the Supabase adapter it is a network
-        // call that can fail, and a failed rewrite must leave this store's own
-        // state (versions, refs, the page map) untouched.
-        await this.paths.remove([{ kind: "page", id }]);
-        this.dropVersions(id);
-        this.options.refs?.remove({ sourceKind: "page", sourceId: id });
-        this.pages.delete(id);
-    }
-}

package/dist/toolset.d.ts

@@ -1,5 +1,5 @@
 export declare const TOOLSET_MARKS: readonly ["bold", "italic", "link"];
-export declare const TOOLSET_NODES: readonly ["h1", "h2", "h3", "h4", "h5", "h6", "bulletList", "orderedList", "blockquote", "image"];
+declare const TOOLSET_NODES: readonly ["h1", "h2", "h3", "h4", "h5", "h6", "bulletList", "orderedList", "blockquote", "image"];
 export type ToolsetMark = (typeof TOOLSET_MARKS)[number];
 export type ToolsetNode = (typeof TOOLSET_NODES)[number];
 export type Toolset = {
@@ -32,3 +32,4 @@ export type Allowed = {
     elements: string[];
 };
 export declare function allowedOf(input: unknown): Allowed;
+export {};

package/dist/toolset.js

@@ -5,7 +5,7 @@ import { schemaOnly } from "./registration.js";
 // registration; a field without a toolset carries the default. `Allowed`
 // is the resolved form the widget reads (spec 2026-09-08 §1).
 export const TOOLSET_MARKS = ["bold", "italic", "link"];
-export const TOOLSET_NODES = ["h1", "h2", "h3", "h4", "h5", "h6", "bulletList", "orderedList", "blockquote", "image"];
+const TOOLSET_NODES = ["h1", "h2", "h3", "h4", "h5", "h6", "bulletList", "orderedList", "blockquote", "image"];
 /** What a richtext field gets when it declares nothing. `h1` is left out:
  *  the section or page shape owns the page's first heading. */
 export const DEFAULT_TOOLSET = {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.51";
+export declare const SMOODLY_VERSION = "0.0.53";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/write-version.mjs from package.json — do not edit.
-export const SMOODLY_VERSION = "0.0.51";
+export const SMOODLY_VERSION = "0.0.53";

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "smoodly",
-  "version": "0.0.51",
-  "description": "Open-source, code-first CMS for Astro and Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
+  "version": "0.0.53",
+  "description": "Open-source, code-first CMS for Astro and Next.js: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/laniakea-studio/smoodly-cms.git",
+    "url": "git+https://github.com/smoodly-io/smoodly.git",
     "directory": "packages/smoodly"
   },
   "type": "module",
@@ -47,10 +47,6 @@
       "types": "./dist/image/index.d.ts",
       "default": "./dist/image/index.js"
     },
-    "./image/config": {
-      "types": "./dist/image/next-config.d.ts",
-      "default": "./dist/image/next-config.js"
-    },
     "./richtext": {
       "types": "./dist/richtext/index.d.ts",
       "default": "./dist/richtext/index.js"
@@ -58,15 +54,10 @@
     "./admin": {
       "types": "./dist/admin/index.d.ts",
       "default": "./dist/admin/index.js"
-    },
-    "./migrations": {
-      "types": "./dist/migrations.d.ts",
-      "default": "./dist/migrations.js"
     }
   },
   "files": [
     "dist",
-    "migrations",
     "bin"
   ],
   "scripts": {
@@ -76,8 +67,7 @@
     "pretest": "node scripts/write-version.mjs && npm run -s build:admin",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "test:supabase": "bash scripts/test-supabase.sh"
+    "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
     "astro": "^7.3.5",
@@ -123,7 +113,6 @@
     "vitest": "^3"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^2.113.0",
     "tsx": "^4.23.15"
   }
 }

package/dist/admin/auth-config.d.ts

@@ -1,6 +0,0 @@
-/** What the browser needs to sign in — public values only (admin/shell/session.ts reads it; the handler and the page data carry it). */
-export type AuthConfig = {
-    url: string;
-    key: string;
-    providers?: ("google" | "github")[];
-};

package/dist/admin/browser/fetch-op.d.ts

@@ -1,10 +0,0 @@
-import type { AdminOpAction } from "../ops.ts";
-/** JSON has no `undefined`: in an array it becomes null, which several ops read as a value (`expected:
- *  null` is "no draft", `undefined` is "skip the check"). Trailing ones are dropped; one between two
- *  arguments cannot be sent and is named here. */
-export declare function wireArgs(args: unknown[]): unknown[];
-/** `fetcher` is the test seam. A network failure rejects; every answer resolves to a typed result.
- *  One operation at a time, in call order: Next queued server actions per browser, and the admin's reads
- *  and writes rely on it (a read sent after a save must see that save's token; a save typed during a
- *  publish must follow the publish). A call that fails does not hold the ones behind it. */
-export declare function fetchOp(url: string, fetcher?: typeof fetch): AdminOpAction;

package/dist/admin/browser/fetch-op.js

@@ -1,44 +0,0 @@
-/** JSON has no `undefined`: in an array it becomes null, which several ops read as a value (`expected:
- *  null` is "no draft", `undefined` is "skip the check"). Trailing ones are dropped; one between two
- *  arguments cannot be sent and is named here. */
-export function wireArgs(args) {
-    let end = args.length;
-    while (end > 0 && args[end - 1] === undefined)
-        end--;
-    const out = args.slice(0, end);
-    if (out.some((a) => a === undefined)) {
-        throw new Error("smoodly: an operation argument is undefined between two others — pass null or a value; JSON cannot carry undefined.");
-    }
-    return out;
-}
-const noResult = (status) => ({ ok: false, code: "internal", message: `smoodly: the admin's endpoint answered ${status} without a result — see the server log.` });
-/** `fetcher` is the test seam. A network failure rejects; every answer resolves to a typed result.
- *  One operation at a time, in call order: Next queued server actions per browser, and the admin's reads
- *  and writes rely on it (a read sent after a save must see that save's token; a save typed during a
- *  publish must follow the publish). A call that fails does not hold the ones behind it. */
-export function fetchOp(url, fetcher = fetch) {
-    const send = async (call) => {
-        const res = await fetcher(url, {
-            method: "POST",
-            credentials: "same-origin",
-            headers: { "content-type": "application/json", ...(call.token ? { authorization: `Bearer ${call.token}` } : {}) },
-            body: JSON.stringify({ path: call.path, args: wireArgs(call.args) }),
-        });
-        let body;
-        try {
-            body = await res.json();
-        }
-        catch {
-            return noResult(res.status);
-        }
-        if (typeof body === "object" && body !== null && typeof body.ok === "boolean")
-            return body;
-        return noResult(res.status);
-    };
-    let last = Promise.resolve();
-    return (call) => {
-        const run = last.then(() => send(call));
-        last = run.catch(() => { });
-        return run;
-    };
-}

package/dist/admin/browser/main.d.ts

@@ -1 +0,0 @@
-export {};