smoodly 0.0.28 → 0.0.29

package/dist/entry-store.d.ts

@@ -40,6 +40,12 @@ export type EntryVersion = {
     /** When the content last changed: the unpublished draft row is rewritten in place (spec 2026-09-13 history §1). */
     savedAt: number;
 };
+/** One entry row for the drift scan (spec 2026-09-27 editor safety §3), whatever its collection:
+ *  locale → the live version's merged fields, null where the locale is not published. */
+export type EntryScan = {
+    record: EntryRecord;
+    live: Record<string, Record<string, unknown> | null>;
+};
 export type EntryUsage = {
     sourceKind: string;
     sourceId: string;
@@ -96,6 +102,8 @@ export interface EntryStore {
     create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions, by?: string): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
+    /** Every entry row, registered collection or not, with each published locale's live fields (spec 2026-09-27 editor safety §3). */
+    scanEntries(): Promise<EntryScan[]>;
     /** Batched read for the resolver: the MERGED fields in `locale`, keyed
      * by id. An id that is missing, absent in the locale, or (with
      * `status`) unpublished there is omitted. With `{ status: "published" }`
@@ -203,6 +211,10 @@ export type SplitFields = {
  *  Every key that is neither localized nor `slug` is shared — declared or
  *  not — so a stray key never disappears into a locale row. */
 export declare function splitFields(fields: Record<string, unknown>, schema: CollectionSchema<any>): SplitFields;
+/** A localized key's value still in the shared fields — saved while the field was shared — stays
+ *  there as every locale's fallback: a write never deletes it (spec 2026-09-27 editor safety §7).
+ *  Reads merge shared, then the row, so each locale shows its own value once it has one. */
+export declare function keepLocalizedShared(before: Record<string, unknown>, shared: Record<string, unknown>, schema: CollectionSchema<any>): Record<string, unknown>;
 export declare function entryLocaleRow(record: EntryRecord, locale: string): EntryLocale;
 /** The merged view of one locale: shared + that locale's fields + its
  *  slug. A fresh object; throws for an absent locale. */
@@ -285,6 +297,7 @@ export declare class MemoryEntryStore 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/entry-store.js

@@ -98,6 +98,17 @@ export function splitFields(fields, schema) {
     }
     return { shared: structuredClone(shared), localized: structuredClone(localized), slug: slugOf(fields) };
 }
+/** A localized key's value still in the shared fields — saved while the field was shared — stays
+ *  there as every locale's fallback: a write never deletes it (spec 2026-09-27 editor safety §7).
+ *  Reads merge shared, then the row, so each locale shows its own value once it has one. */
+export function keepLocalizedShared(before, shared, schema) {
+    const out = { ...shared };
+    for (const key of localizedKeys(schema)) {
+        if (key in before && !(key in out))
+            out[key] = structuredClone(before[key]);
+    }
+    return out;
+}
 export function entryLocaleRow(record, locale) {
     const row = record.locales[locale];
     if (!row)
@@ -408,7 +419,7 @@ export class MemoryEntryStore {
             throw entryErrors.noSlug(collection);
         this.assertSiblingSlug(collection, entry.parentId, locale, slug, id);
         const before = { fields: entry.fields, row: { ...row } };
-        entry.fields = shared;
+        entry.fields = keepLocalizedShared(before.fields, shared, schema);
         row.fields = localized;
         row.slug = slug;
         try {
@@ -449,7 +460,7 @@ export class MemoryEntryStore {
         if (!snapshot)
             throw entryErrors.nothingPublished(collection, id, locale);
         const { shared, localized } = splitFields(snapshot.fields, schema);
-        entry.fields = shared;
+        entry.fields = keepLocalizedShared(entry.fields, shared, schema);
         row.fields = localized;
         const abandoned = row.draftVersionId;
         row.draftVersionId = row.publishedVersionId;
@@ -517,6 +528,18 @@ export class MemoryEntryStore {
         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()]
@@ -535,7 +558,7 @@ export class MemoryEntryStore {
         if (versionId === row.publishedVersionId)
             return this.discardDraft(collection, id, locale, by, expected);
         const { shared, localized } = splitFields(version.fields, schema);
-        entry.fields = shared;
+        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);

package/dist/index.d.ts

@@ -51,7 +51,7 @@ export type { PathIndex } from "./path-index.ts";
 export { MemoryEntryStore } from "./entry-store.ts";
 export { SupabaseEntryStore } from "./supabase-entry-store.ts";
 export { SupabasePathIndex } from "./supabase-path-index.ts";
-export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
+export type { EntryStore, EntryRecord, EntryLocale, EntryVersion, EntryScan, EntryUsage, ListOptions, CreateEntryOptions, AddEntryLocaleOptions, EntryStoreOptions, Where, WhereValue, } from "./entry-store.ts";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.ts";
 export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.ts";
 export type { AffectedTargets } from "./revalidate.ts";
@@ -60,7 +60,7 @@ export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve
 export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
 export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions, LocaleAlternate, PageAlternate } from "./paths.ts";
 export { fixedPathFor } from "./localize.ts";
-export type { PageStore, PageRecord, PageLocale, PageVersion, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
+export type { PageStore, PageRecord, PageLocale, PageVersion, PageScan, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
 export type { FieldBuilder, Descriptor, ValueOf, Option, OptionInput, OptionValue } from "./fields.ts";

package/dist/render.js

@@ -1,5 +1,5 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { EMPTY_ATTR, ZONE_ATTR } from "./marks.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { EMPTY_ATTR, NODE_ATTR, ZONE_ATTR } from "./marks.js";
 import { SMD_KEY } from "./section-wrapper.js";
 import { DEFAULT_STYLE_VALUES } from "./styles.js";
 import { CUSTOM_NODE_TYPE, createCustomSection } from "./custom/index.js";
@@ -23,6 +23,11 @@ export function Zone({ of: content }) {
     return (_jsx(_Fragment, { children: nodes.map((node) => {
             const Component = content.components.get(node.type);
             if (!Component) {
+                // Editor mode draws a box the bridge can measure, so the node is selectable in place
+                // (spec 2026-09-27 editor safety §5); the site renders nothing, as before.
+                if (content.editor) {
+                    return (_jsxs("div", { [NODE_ATTR]: node.id, style: { padding: "24px 16px", border: "1px dashed #b54708", color: "#b54708", font: "500 14px/1.4 system-ui, sans-serif", textAlign: "center" }, children: ["Unknown section `", node.type, "`"] }, node.id));
+                }
                 console.warn(`smoodly: no registered component for node type "${node.type}" — skipping.`);
                 return null;
             }

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.29",
   "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": {