smoodly 0.0.28 → 0.0.30

package/dist/section-guard.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CrashPlaceholder } from "./section-crash.js";
+/** The paired component's own view call, set by pair() and the custom section — only for a plain-function view. */
+export const RENDER_VIEW = Symbol("smoodly.renderView");
+/** A view the guard may call: a plain function — not a client reference or memo/forwardRef ($$typeof), not a class. */
+export function isPlainView(View) {
+    if (typeof View !== "function")
+        return false;
+    const v = View;
+    return v.$$typeof === undefined && !v.prototype?.isReactComponent;
+}
+/** The placeholder shows in the canvas, and under `next dev` so a developer never misses their own crash. */
+const placeholderShown = (editor) => editor || process.env.NODE_ENV === "development";
+function failed(error, ctx) {
+    ctx.rethrow?.(error); // notFound(), redirects and bailouts are control flow, not crashes
+    console.error(`smoodly: section "${ctx.type}" (node ${ctx.id}) failed to render and is left out of the page.`, error);
+    return placeholderShown(ctx.editor) ? _jsx(CrashPlaceholder, { id: ctx.id, title: ctx.title, error: error, live: "section" }) : null;
+}
+const isThenable = (v) => typeof v === "object" && v !== null && typeof v.then === "function";
+/** A section through the guard when its component offers the view call; any other component as an element, unguarded. */
+export function renderGuarded(Component, props, ctx) {
+    const render = Component[RENDER_VIEW];
+    if (!render)
+        return _jsx(Component, { ...props });
+    try {
+        const out = render(props);
+        if (!isThenable(out))
+            return out;
+        // Settled up front, so a rejection is never unhandled while React gets to the guard.
+        const settled = Promise.resolve(out).then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        return _jsx(SectionGuard, { settled: settled, ctx: ctx });
+    }
+    catch (error) {
+        return failed(error, ctx);
+    }
+}
+/** An async section, awaited in place — no <Suspense>, so it renders where it always did. */
+export async function SectionGuard({ settled, ctx }) {
+    const result = await settled;
+    return result.ok ? result.value : failed(result.error, ctx);
+}

package/dist/store.d.ts

@@ -52,10 +52,18 @@ export type PageVersion = {
     tree: PageTree;
     savedAt: number;
 };
+/** One page for the drift scan (spec 2026-09-27 editor safety §3): locale → draft and live tree; null where there is none. */
+export type PageScan = {
+    record: PageRecord;
+    draft: Record<string, PageTree | null>;
+    live: Record<string, PageTree | null>;
+};
 export interface PageStore {
     createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
+    /** 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>;
@@ -212,6 +220,7 @@ export declare class MemoryPageStore implements PageStore {
     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>;

package/dist/store.js

@@ -277,6 +277,14 @@ export class MemoryPageStore {
         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.

package/dist/supabase-entry-store.d.ts

@@ -1,6 +1,6 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { CollectionSchema } from "./collections.ts";
-import type { AddEntryLocaleOptions, CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryUsage, EntryVersion, ListOptions } from "./entry-store.ts";
+import type { AddEntryLocaleOptions, CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryScan, EntryUsage, EntryVersion, ListOptions } from "./entry-store.ts";
 import { type DraftToken } from "./draft-token.ts";
 export declare class SupabaseEntryStore implements EntryStore {
     private db;
@@ -68,6 +68,7 @@ export declare class SupabaseEntryStore implements EntryStore {
     discardDraft(collection: string, id: string, locale: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions, by?: string): Promise<EntryRecord>;
     removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
+    scanEntries(): Promise<EntryScan[]>;
     listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
     restore(collection: string, id: string, locale: string, versionId: string, by?: string, expected?: DraftToken | null): Promise<EntryRecord>;
     getVersion(collection: string, versionId: string): Promise<EntryVersion | null>;

package/dist/supabase-entry-store.js

@@ -7,7 +7,7 @@
 // calls the smoodly_reorder SQL function: one statement, updated_at
 // untouched.
 import { collectionDepth, collectionOrder } from "./collections.js";
-import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, schemaOf, splitFields, } from "./entry-store.js";
+import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, keepLocalizedShared, schemaOf, splitFields, } from "./entry-store.js";
 import { globalEntryId } from "./global-id.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { groupRedirects } from "./store.js";
@@ -473,11 +473,12 @@ export class SupabaseEntryStore {
         if (isGlobalSchema(schema) && slug !== null)
             throw entryErrors.noSlug(collection);
         await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
+        const nodeFields = keepLocalizedShared(before.fields, shared, schema);
         // The snapshot of what the row is about to hold, written under the guard BEFORE the live
         // columns change (spec 2026-09-26 concurrency §3): a stale save leaves nothing behind.
-        const next = { ...before, fields: shared, locales: { ...before.locales, [locale]: { ...row, fields: localized, slug } } };
+        const next = { ...before, fields: nodeFields, locales: { ...before.locales, [locale]: { ...row, fields: localized, slug } } };
         const { created } = await this.recordVersion(next, locale, expected !== undefined);
-        await this.updateNode(id, { fields: shared });
+        await this.updateNode(id, { fields: nodeFields });
         await this.updateLocale(id, locale, { slug, fields: localized }, { by });
         const record = await this.must(collection, id);
         try {
@@ -535,7 +536,7 @@ export class SupabaseEntryStore {
         const matched = await this.guardedUpdateLocale(id, locale, { fields: localized, draft_version_id: row.publishedVersionId }, { by, guard: expected !== undefined ? row.draftVersionId : undefined });
         if (!matched)
             throw await this.stale(collection, id, locale);
-        await this.updateNode(id, { fields: shared });
+        await this.updateNode(id, { fields: keepLocalizedShared(record.fields, shared, schema) });
         if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
             // The pointer moved first, so a failure here leaves a stray row, never a dangling pointer.
             const gone = await this.db.from("entry_versions").delete().eq("id", row.draftVersionId);
@@ -598,6 +599,26 @@ export class SupabaseEntryStore {
         await this.writeRefs(final);
         return final;
     }
+    async scanEntries() {
+        const res = await this.db.from("entries").select(SELECT).order("created_at", { ascending: true }).order("id", { ascending: true });
+        if (res.error)
+            this.fail(res.error.message);
+        const records = res.data.map(toRecord);
+        const ids = records.flatMap((r) => Object.values(r.locales).flatMap((row) => (row.status === "published" && row.publishedVersionId ? [row.publishedVersionId] : [])));
+        // In chunks: one in() over hundreds of ids would overflow the request URL.
+        const snaps = new Map();
+        for (let i = 0; i < ids.length; i += 100) {
+            for (const [id, fields] of await this.versionFields(ids.slice(i, i + 100)))
+                snaps.set(id, fields);
+        }
+        return records.map((record) => ({
+            record,
+            live: Object.fromEntries(Object.entries(record.locales).map(([l, row]) => [
+                l,
+                row.status !== "published" ? null : (row.publishedVersionId ? snaps.get(row.publishedVersionId) : undefined) ?? entryFieldsIn(record, l),
+            ])),
+        }));
+    }
     async listVersions(collection, id, locale) {
         await this.must(collection, id);
         const res = await this.db
@@ -621,7 +642,8 @@ export class SupabaseEntryStore {
         assertFresh(row, expected);
         if (versionId === row.publishedVersionId)
             return this.discardDraft(collection, id, locale, by, expected);
-        const { shared, localized } = splitFields(version.fields, schema);
+        const { shared: split, localized } = splitFields(version.fields, schema);
+        const shared = keepLocalizedShared(entry.fields, split, schema);
         // The snapshot first, under the guard, as in update.
         const next = { ...entry, fields: shared, locales: { ...entry.locales, [locale]: { ...row, fields: localized } } };
         await this.recordVersion(next, locale, expected !== undefined);

package/dist/supabase-store.d.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { type AddLocaleOptions, type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
+import { type AddLocaleOptions, type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion, type PageScan } from "./store.ts";
 import type { PageTree } from "./render.tsx";
 import type { PathRow } from "./path-index.ts";
 import { type DraftToken } from "./draft-token.ts";
@@ -58,6 +58,7 @@ export declare class SupabasePageStore implements PageStore {
     private hardDelete;
     createPage(input: CreatePageInput, by?: string): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
+    scanTrees(): Promise<PageScan[]>;
     listPages(): Promise<PageRecord[]>;
     /** The site's one warning per process (spec 2026-09-26 §5): fired by the first locate, never blocking. */
     private schemaChecked;

package/dist/supabase-store.js

@@ -322,6 +322,33 @@ export class SupabasePageStore {
     getPage(id) {
         return this.row(id);
     }
+    async scanTrees() {
+        const records = await this.listPages();
+        const ids = new Set();
+        for (const r of records)
+            for (const row of Object.values(r.locales)) {
+                if (row.draftVersionId)
+                    ids.add(row.draftVersionId);
+                if (row.publishedVersionId)
+                    ids.add(row.publishedVersionId);
+            }
+        // In chunks: one in() over hundreds of ids would overflow the request URL.
+        const trees = new Map();
+        const all = [...ids];
+        for (let i = 0; i < all.length; i += 100) {
+            const res = await this.db.from("page_versions").select("id, tree").in("id", all.slice(i, i + 100));
+            if (res.error)
+                this.fail(res.error.message);
+            for (const v of res.data)
+                trees.set(v.id, v.tree);
+        }
+        const tree = (id) => (id ? trees.get(id) ?? null : null);
+        return records.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() {
         const res = await this.db
             .from("pages")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {