smoodly 0.0.37 → 0.0.39

package/dist/site.js

@@ -6,9 +6,11 @@ import { globalNodeId, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
 import { SMD_KEY } from "./section-wrapper.js";
 import { resolveStyleValues } from "./styles.js";
 import { resolveCustom } from "./custom/index.js";
-import { addressMap, codeAddresses } from "./addresses.js";
+import { addressMap, codeAddresses, lastPart } from "./addresses.js";
 import { fullPath, servedAnchor } from "./anchors.js";
 import { withDefaults } from "./field-defaults.js";
+import { modelKey } from "./model-key.js";
+import { SMOODLY_VERSION } from "./version.js";
 import { toEntryItem, toPageItem } from "./read-shapes.js";
 import { entrySeo, pageSeo, SEO_KEY } from "./seo.js";
 /** The `page` prop for a loaded page. `href` is the app's seam from a
@@ -36,11 +38,22 @@ export function createSmoodlySite(options) {
     const custom = resolveCustom(options.custom);
     const elements = elementSchemas(options.elements);
     // Code-owned addresses from the site's own registry (spec 2026-09-29 nested paths §3): a code-owned root's path.
-    const addresses = addressMap(codeAddresses({ locales, pages: options.pages, collections: options.collections }));
+    const codeOwned = codeAddresses({ locales, pages: options.pages, collections: options.collections });
+    const addresses = addressMap(codeOwned);
     const pathOpts = { locales, homePageSlug, addresses };
     /** The same addresses as the path index sees them: an entry's stored part joined to its collection's (spec 2026-09-29 anchored paths §2). */
     const anchors = { addresses, homePageSlug, defaultLocale: locales.default };
     const mounted = options.collections.filter((c) => c.path !== undefined);
+    // Every cached read keys on it (spec 2026-09-30 tester findings §3): an upgrade or a model change starts a fresh cache.
+    const cacheKey = `${SMOODLY_VERSION}:${modelKey({
+        // Whole schemas: a collection's order, tree or title field changes a read as its fields do (functions drop out in the hash).
+        collections: options.collections,
+        globals: (options.globals ?? []).map((g) => ({ name: g.name, fields: g.fields, section: g.section })),
+        sections: options.sections.map((x) => ("schema" in x ? x.schema : x)),
+        elements: (options.elements ?? []).map((x) => ("schema" in x ? x.schema : x)),
+        pages: options.pages.map((x) => x.schema),
+        locales, homePageSlug, styles, custom,
+    })}`;
     /** The resolver's fetcher, bound to a locale: the merged fields of that
      *  locale — published ones (a versioned collection's snapshot) on the
      *  public path, the live rows in draft mode. */
@@ -336,9 +349,33 @@ export function createSmoodlySite(options) {
             };
         },
     };
+    const codePath = (address) => (address === homePageSlug ? "/" : `/${address}`);
+    function codePage(locale, path) {
+        const spec = codeOwned.find((a) => a.template !== null && a.segments[locale] !== undefined && codePath(a.segments[locale]) === path);
+        if (!spec || !locales.supported.includes(locale))
+            return null;
+        const template = spec.template;
+        const withSeo = options.pages.some((x) => x.schema.kind === "page" && x.schema.name === template && x.schema.seo === true);
+        return {
+            kind: "page",
+            locale,
+            // No record yet: the id only has to be stable and never a stored one.
+            record: { id: `code:${template}`, parentId: null, template, fixed: spec.key, locales: {}, sort: null },
+            template,
+            tree: { zones: {} },
+            title: spec.title,
+            path,
+            fields: withDefaults(undefined, pageFields(template)),
+            ancestors: [],
+            children: [],
+            locales: Object.fromEntries(Object.entries(spec.segments).map(([l, address]) => [l, { slug: lastPart(address), path: codePath(address) }])),
+            ...(withSeo ? { seo: pageSeo(undefined, spec.title) } : {}),
+        };
+    }
     const site = {
         locales,
         homePageSlug,
+        cacheKey,
         styles,
         custom,
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
@@ -352,6 +389,7 @@ export function createSmoodlySite(options) {
             const target = await site.locate(locale, path);
             return target && !target.redirect ? site.load(target, locale, path, opts) : null;
         },
+        codePage,
         ...api,
     };
     return site;

package/dist/supabase-entry-store.js

@@ -48,6 +48,8 @@ function toRecord(row) {
 function toVersion(row) {
     return { id: row.id, entryId: row.entry_id, locale: row.locale, fields: row.fields, savedAt: Date.parse(row.saved_at) };
 }
+/** Rows per request when `list` reads a whole collection: under PostgREST's default cap. */
+const LIST_PAGE = 1000;
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
         this.db = db;
@@ -391,47 +393,61 @@ export class SupabaseEntryStore {
         // EVERY locale row of each record (spec 2026-09-11 §3), ordered by locale
         // so a record's key order never depends on physical row order.
         const gate = options?.status !== undefined || options?.locale !== undefined;
-        let query = this.db
-            .from("entries")
-            .select(gate ? `${SELECT}, gate:entry_locales!inner(locale)` : SELECT)
-            .eq("collection", collection)
-            .order("locale", { referencedTable: "entry_locales", ascending: true });
-        if (gate) {
-            query = query.eq("gate.locale", options.locale ?? this.locales.default);
-            if (options.status !== undefined)
-                query = query.eq("gate.status", options.status);
-        }
-        if (options?.parent !== undefined) {
-            query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
-        }
-        for (const [key, want] of Object.entries(options?.where ?? {})) {
-            // Any-of compares the text form (`->>`). A scalar is JSONB containment;
-            // an array-valued field (checkboxes, refList, list, tags) contains `[value]`,
-            // a scalar field `value` — the memory adapter's matchesWhere agrees.
-            if (Array.isArray(want)) {
-                query = query.in(`fields->>${key}`, want.map(String));
+        // Built per request: without a `limit` the list is read in pages, because
+        // PostgREST caps one response (1000 rows by default) without saying so.
+        const build = () => {
+            let query = this.db
+                .from("entries")
+                .select(gate ? `${SELECT}, gate:entry_locales!inner(locale)` : SELECT)
+                .eq("collection", collection)
+                .order("locale", { referencedTable: "entry_locales", ascending: true });
+            if (gate) {
+                query = query.eq("gate.locale", options.locale ?? this.locales.default);
+                if (options.status !== undefined)
+                    query = query.eq("gate.status", options.status);
+            }
+            if (options?.parent !== undefined) {
+                query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
+            }
+            for (const [key, want] of Object.entries(options?.where ?? {})) {
+                // Any-of compares the text form (`->>`). A scalar is JSONB containment;
+                // an array-valued field (checkboxes, refList, list, tags) contains `[value]`,
+                // a scalar field `value` — the memory adapter's matchesWhere agrees.
+                if (Array.isArray(want)) {
+                    query = query.in(`fields->>${key}`, want.map(String));
+                }
+                else {
+                    const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
+                    query = query.contains("fields", { [key]: inArray ? [want] : want });
+                }
+            }
+            const order = options?.order ?? collectionOrder(schema);
+            if (order === "manual") {
+                // `id` last in both orders: a stable order, so no row falls between two pages.
+                query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true }).order("id", { ascending: true });
             }
             else {
-                const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
-                query = query.contains("fields", { [key]: inArray ? [want] : want });
+                // `fields->x`, not `->>x`: ordering by the jsonb VALUE of the SHARED
+                // field (an order field is never localized), matching the memory comparator.
+                const column = order.by === "createdAt" ? "created_at" : order.by === "updatedAt" ? "updated_at" : `fields->${order.by}`;
+                query = query.order(column, { ascending: order.direction === "asc", nullsFirst: false }).order("id", { ascending: true });
             }
-        }
-        const order = options?.order ?? collectionOrder(schema);
-        if (order === "manual") {
-            query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true });
-        }
-        else {
-            // `fields->x`, not `->>x`: ordering by the jsonb VALUE of the SHARED
-            // field (an order field is never localized), matching the memory comparator.
-            const column = order.by === "createdAt" ? "created_at" : order.by === "updatedAt" ? "updated_at" : `fields->${order.by}`;
-            query = query.order(column, { ascending: order.direction === "asc", nullsFirst: false }).order("id", { ascending: true });
-        }
+            return query;
+        };
+        const rows = (res) => {
+            if (res.error)
+                this.fail(res.error.message);
+            return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
+        };
         if (typeof options?.limit === "number")
-            query = query.limit(options.limit);
-        const res = await query;
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
+            return rows(await build().limit(options.limit));
+        const all = [];
+        for (let from = 0;; from += LIST_PAGE) {
+            const page = rows(await build().range(from, from + LIST_PAGE - 1));
+            all.push(...page);
+            if (page.length < LIST_PAGE)
+                return all;
+        }
     }
     async query(collection, q) {
         const schema = this.schema(collection);

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

@@ -10,6 +10,12 @@ export declare class SupabaseMemberStore implements MemberStore {
     /** The admin API has no lookup by email: page through the users (tens, not thousands). */
     private userIdByEmail;
     invite(input: InviteInput): Promise<InviteResult>;
+    private upsertRow;
+    createAccount(input: {
+        email: string;
+        password: string;
+        role: MemberRole;
+    }): Promise<MemberRecord>;
     setRole(userId: string, role: MemberRole): Promise<MemberRecord>;
     remove(userId: string): Promise<void>;
 }

package/dist/supabase-member-store.js

@@ -51,14 +51,32 @@ export class SupabaseMemberStore {
         else {
             throw new Error(`smoodly: ${sent.error.message}`);
         }
+        return { member: await this.upsertRow(userId, input.email, input.role), invited };
+    }
+    async upsertRow(userId, email, role) {
         const res = await this.db
             .from("members")
-            .upsert({ user_id: userId, email: input.email, role: input.role }, { onConflict: "space_id,user_id" })
+            .upsert({ user_id: userId, email, role }, { onConflict: "space_id,user_id" })
             .select("user_id, email, role")
             .single();
         if (res.error)
             throw new Error(`smoodly: ${res.error.message}`);
-        return { member: this.toRecord(res.data), invited };
+        return this.toRecord(res.data);
+    }
+    async createAccount(input) {
+        const created = await this.db.auth.admin.createUser({ email: input.email, password: input.password, email_confirm: true });
+        let userId;
+        if (!created.error) {
+            userId = created.data.user.id;
+        }
+        else if (created.error.code === "email_exists" || /already (been )?registered/i.test(created.error.message)) {
+            // An existing account keeps its password; it only gains the membership.
+            userId = await this.userIdByEmail(input.email);
+        }
+        else {
+            throw new Error(`smoodly: ${created.error.message}`);
+        }
+        return this.upsertRow(userId, input.email, input.role);
     }
     async setRole(userId, role) {
         const res = await this.db.from("members").update({ role }).eq("user_id", userId).select("user_id, email, role").maybeSingle();

package/dist/supabase-store.js

@@ -8,7 +8,8 @@
 // rewritten through ONE RPC per write, so a collision rolls back.
 import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, storeAnchors, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
-import { SCHEMA_VERSION_KEY, schemaBehind, schemaBehindMessage } from "./schema-version.js";
+import { schemaBehind, schemaBehindMessage, secretKeyRefusedMessage } from "./schema-version.js";
+import { readSchemaVersion } from "./schema-read.js";
 import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
 import { assertDepth, assertSegment, isHomeNode, pagePathRows, rewriteTargets } from "./paths.js";
@@ -381,25 +382,26 @@ export class SupabasePageStore {
     resolvePath(locale, path) {
         if (!this.schemaChecked) {
             this.schemaChecked = true;
-            void this.schemaVersion()
-                .then((v) => {
-                if (schemaBehind(v))
-                    console.warn(schemaBehindMessage(v));
+            // Once per store: a wrong key is named as a wrong key, not as an old schema (spec 2026-09-30 tester findings §4).
+            void readSchemaVersion(this.db)
+                .then((read) => {
+                if ("missing" in read)
+                    console.warn(read.missing === "key" ? secretKeyRefusedMessage : schemaBehindMessage(null));
+                else if (schemaBehind(read.version))
+                    console.warn(schemaBehindMessage(read.version));
             })
                 .catch(() => { });
         }
         return this.paths.resolve(locale, path);
     }
     async schemaVersion() {
-        const res = await this.db.from("smoodly_meta").select("value").eq("key", SCHEMA_VERSION_KEY).maybeSingle();
-        if (res.error) {
-            // PGRST205: not in PostgREST's schema cache; 42P01: undefined table.
-            if (res.error.code === "PGRST205" || res.error.code === "42P01")
-                return null;
-            this.fail(res.error.message);
-        }
-        const n = Number(res.data?.value);
-        return Number.isInteger(n) ? n : null;
+        const read = await readSchemaVersion(this.db);
+        if ("version" in read)
+            return read.version;
+        // The table exists and the row is hidden: the key is not a secret key.
+        if (read.missing === "key")
+            throw new Error(secretKeyRefusedMessage);
+        return null;
     }
     pathsOf(id) {
         return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});

package/dist/tags.d.ts

@@ -17,3 +17,6 @@ export declare function addTags(current: readonly string[], input: string, opts?
  *  entries disagree on a tag's casing the most used one wins, a tie going to plain string
  *  order — never to the order the values arrived in, which is the store's business. */
 export declare function distinctTags(values: readonly unknown[]): string[];
+/** A tags value as stored (spec 2026-09-30 tester findings §5): normalized, one per
+ *  case-folded tag, each taking the spelling already used in the collection. */
+export declare function canonicalTags(values: readonly unknown[], known: readonly string[]): string[];

package/dist/tags.js

@@ -48,3 +48,19 @@ export function distinctTags(values) {
     const pick = (counts) => [...counts].sort(([a, n], [b, m]) => m - n || (a < b ? -1 : 1))[0][0];
     return [...variants.values()].map(pick).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
 }
+/** A tags value as stored (spec 2026-09-30 tester findings §5): normalized, one per
+ *  case-folded tag, each taking the spelling already used in the collection. */
+export function canonicalTags(values, known) {
+    const out = [];
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const typed = normalizeTag(value);
+        if (typed === "")
+            continue;
+        const tag = known.find((k) => sameTag(k, typed)) ?? typed;
+        if (!out.some((t) => sameTag(t, tag)))
+            out.push(tag);
+    }
+    return out;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SMOODLY_VERSION = "0.0.39";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "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": {
@@ -54,8 +54,9 @@
     "bin"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "node scripts/write-version.mjs && rm -rf dist && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build",
+    "pretest": "node scripts/write-version.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
@@ -82,17 +83,19 @@
   },
   "dependencies": {
     "@supabase/supabase-js": "^2.113.0",
-    "@tiptap/core": "3.31.3",
-    "@tiptap/extension-blockquote": "3.31.3",
-    "@tiptap/extension-bold": "3.31.3",
-    "@tiptap/extension-heading": "3.31.3",
-    "@tiptap/extension-italic": "3.31.3",
-    "@tiptap/extension-link": "3.31.3",
-    "@tiptap/extension-list": "3.31.3",
-    "@tiptap/pm": "3.31.3",
-    "@tiptap/react": "3.31.3",
-    "@tiptap/starter-kit": "3.31.3",
-    "@tiptap/suggestion": "3.31.3",
+    "@tiptap/core": "3.31.4",
+    "@tiptap/extension-blockquote": "3.31.4",
+    "@tiptap/extension-bold": "3.31.4",
+    "@tiptap/extension-bubble-menu": "3.31.4",
+    "@tiptap/extension-floating-menu": "3.31.4",
+    "@tiptap/extension-heading": "3.31.4",
+    "@tiptap/extension-italic": "3.31.4",
+    "@tiptap/extension-link": "3.31.4",
+    "@tiptap/extension-list": "3.31.4",
+    "@tiptap/pm": "3.31.4",
+    "@tiptap/react": "3.31.4",
+    "@tiptap/starter-kit": "3.31.4",
+    "@tiptap/suggestion": "3.31.4",
     "lucide-react": "^1.41.0",
     "tsx": "^4.23.15"
   }