smoodly 0.0.38 → 0.0.40

package/dist/admin/ops-impl.js

@@ -1,5 +1,5 @@
 import { entryErrors, entryFieldsIn, entryTitleIn } from "../entry-store.js";
-import { chainOf, isSegment, pagePathIn } from "../paths.js";
+import { chainOf, isSegment, pagePathIn, slugify } from "../paths.js";
 import { servedAnchor } from "../anchors.js";
 import { canonicalTags, distinctTags } from "../tags.js";
 import { can, isMemberRole, normalizeRole } from "../permissions.js";
@@ -112,6 +112,18 @@ const classify = (e) => {
         return err("conflict", message);
     return err("internal", message);
 };
+/** A new entry without a slug gets one from the field `f.slug({ from })` follows, as the admin's form
+ *  fills it (spec 2026-09-28 ASCII slugs §5), so a script needs no slug of its own. A given slug stays. */
+function followSlug(fields, descriptors) {
+    const d = descriptors.slug;
+    if (d?.type !== "slug" || d.from === undefined)
+        return fields;
+    if (typeof fields.slug === "string" && fields.slug !== "")
+        return fields;
+    const source = fields[d.from];
+    const slug = typeof source === "string" ? slugify(source) : "";
+    return slug === "" ? fields : { ...fields, slug };
+}
 export function createAdminOps(deps) {
     const { config, pages, entries, effects } = deps;
     const href = deps.href ?? ((path) => path);
@@ -783,7 +795,7 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const created = await entries.create(collection, withDefaults(await foldTags(collection, input.locale, input.fields, descriptors), descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
+                const created = await entries.create(collection, withDefaults(await foldTags(collection, input.locale, followSlug(input.fields, descriptors), descriptors), descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
                 expireCollection(collection);
                 return ok(created);
             }),

package/dist/cli/space-io.d.ts

@@ -7,10 +7,11 @@ export type SpaceConnection = {
 export declare const MEDIA_BUCKET = "media";
 /** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
 export declare const PAGE_ROWS = 1000;
-/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). */
-export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): void;
-/** The app's content client, from its env. */
-export declare function connectFromEnv(cwd: string): SpaceConnection;
+/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
+export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): string[];
+/** The app's content client, from its env. Run outside the app, the missing keys are a missing
+ *  folder, so the error names the folder it looked in. */
+export declare function connectFromEnv(cwd: string, env?: Record<string, string | undefined>): SpaceConnection;
 export { readSchemaVersion } from "../schema-read.ts";
 export declare function schemaRefusal(missing: "key" | "schema", command: "Export" | "Import"): string;
 /** Every row of one table in one space, paged in primary-key order. The space filter is explicit: a service-role key sees every space. */

package/dist/cli/space-io.js

@@ -13,22 +13,29 @@ import { ROW_KEY } from "../space-transfer.js";
 export const MEDIA_BUCKET = "media";
 /** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
 export const PAGE_ROWS = 1000;
-/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). */
+/** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). Returns the files it read. */
 export function loadAppEnv(cwd, env = process.env) {
+    const read = [];
     for (const name of [".env.local", ".env"]) {
         const file = join(cwd, name);
         if (!existsSync(file))
             continue;
+        read.push(name);
         for (const [key, value] of Object.entries(parseEnv(readFileSync(file, "utf8")))) {
             if (env[key] === undefined)
                 env[key] = value;
         }
     }
+    return read;
 }
-/** The app's content client, from its env. */
-export function connectFromEnv(cwd) {
-    loadAppEnv(cwd);
-    return { db: createSmoodlyClient(resolveSmoodlyEnv(process.env)) };
+/** The app's content client, from its env. Run outside the app, the missing keys are a missing
+ *  folder, so the error names the folder it looked in. */
+export function connectFromEnv(cwd, env = process.env) {
+    const read = loadAppEnv(cwd, env);
+    if (read.length === 0 && (!env.SMOODLY_URL || !env.SMOODLY_SECRET_KEY)) {
+        throw new Error(`smoodly: no .env.local or .env in ${cwd} — run this in your app's folder.`);
+    }
+    return { db: createSmoodlyClient(resolveSmoodlyEnv(env)) };
 }
 export { readSchemaVersion } from "../schema-read.js";
 export function schemaRefusal(missing, command) {

package/dist/client.js

@@ -11,11 +11,25 @@ export function clientOptions(env) {
     // without one (spec 2026-09-30 tester findings §4): a self-host service role is a valid apikey.
     return { url: env.url, key: env.publishableKey || env.secretKey, headers: { Authorization: `Bearer ${env.secretKey}` } };
 }
+/** fetch that names the address when the network fails: supabase-js reports only
+ *  "TypeError: fetch failed", which names neither the variable nor the URL. */
+function namedFetch(url) {
+    return async (input, init) => {
+        try {
+            return await fetch(input, init);
+        }
+        catch (e) {
+            if (e instanceof Error && e.name === "AbortError")
+                throw e;
+            throw new TypeError(`can't reach SMOODLY_URL (${url}): ${e instanceof Error ? e.message : String(e)}`);
+        }
+    };
+}
 /** The server-side client the stores are built on. */
 export function createSmoodlyClient(env) {
     const options = clientOptions(env);
     return createClient(options.url, options.key, {
-        global: { headers: options.headers },
+        global: { headers: options.headers, fetch: namedFetch(options.url) },
         auth: { persistSession: false, autoRefreshToken: false },
     });
 }

package/dist/content/content-api.d.ts

@@ -43,6 +43,12 @@ export declare function createSmoodlyContent(deps: ContentDeps): {
             title?: string;
         }): Promise<PageRecord>;
         publish: (id: string, locale: string) => Promise<PageRecord>;
+        /** Every page present in `locale` (the default language unless given), code-owned ones included and
+         *  folders left out, optionally only one page type: what a script walks to change many pages. */
+        list(options?: {
+            locale?: string;
+            template?: string;
+        }): Promise<PageRecord[]>;
         /** A code-owned address with no record gets it created the way the admin's Pages list does (spec §2). */
         find(locale: string, path: string): Promise<PageRecord | null>;
     };
@@ -54,6 +60,10 @@ export declare function createSmoodlyContent(deps: ContentDeps): {
             fields?: Record<string, unknown>;
         }): Promise<EntryRecord>;
         publish: (collection: string, id: string, locale: string) => Promise<EntryRecord>;
+        list: (collection: string, options?: {
+            where?: Record<string, unknown>;
+            locale?: string;
+        }) => Promise<EntryRecord[]>;
         find(collection: string, match: {
             slug: string;
             locale?: string;

package/dist/content/content-api.js

@@ -65,6 +65,25 @@ export function createSmoodlyContent(deps) {
     async function updateEntry(collection, id, locale, fields) {
         return must(ops.entries.save(collection, id, locale, fields));
     }
+    /** The entries present in `locale` (the default language unless given) whose fields match every `where` key:
+     *  shared and that locale's fields and its slug, equal, or held by an array field (tags, refList). */
+    async function listEntries(collection, options = {}) {
+        if (!deps.config.registry.collections?.some((c) => c.name === collection)) {
+            throw new SmoodlyContentError({ code: "not_found", message: `smoodly: no collection named "${collection}".` });
+        }
+        const locale = options.locale ?? def;
+        const where = Object.entries(options.where ?? {});
+        return (await must(ops.entries.list(collection))).filter((e) => {
+            const row = e.locales[locale];
+            if (!row)
+                return false;
+            const fields = { ...e.fields, ...row.fields, slug: row.slug };
+            return where.every(([key, want]) => {
+                const value = fields[key];
+                return Array.isArray(value) ? value.includes(want) : value === want;
+            });
+        });
+    }
     return {
         pages: {
             create: (input) => must(ops.pages.create(input)),
@@ -88,6 +107,12 @@ export function createSmoodlyContent(deps) {
                 }));
             },
             publish: (id, locale) => must(ops.pages.publish(id, locale)),
+            /** Every page present in `locale` (the default language unless given), code-owned ones included and
+             *  folders left out, optionally only one page type: what a script walks to change many pages. */
+            async list(options = {}) {
+                const locale = options.locale ?? def;
+                return (await must(ops.pages.list())).filter((p) => p.template !== null && p.locales[locale] !== undefined && (options.template === undefined || p.template === options.template));
+            },
             /** A code-owned address with no record gets it created the way the admin's Pages list does (spec §2). */
             async find(locale, path) {
                 const found = await findPage(locale, path);
@@ -105,10 +130,9 @@ export function createSmoodlyContent(deps) {
                 return options.fields ? updateEntry(collection, id, locale, options.fields) : added;
             },
             publish: (collection, id, locale) => must(ops.entries.setStatus(collection, id, locale, "published")),
+            list: listEntries,
             async find(collection, match) {
-                const locale = match.locale ?? def;
-                const all = await must(ops.entries.list(collection));
-                return all.find((e) => e.locales[locale]?.slug === match.slug) ?? null;
+                return (await listEntries(collection, { where: { slug: match.slug }, locale: match.locale }))[0] ?? null;
             },
         },
         globals: {

package/dist/env.d.ts

@@ -15,6 +15,11 @@ export type SmoodlyEnv = {
  *  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
+ *  put localhost into every page's head. */
+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;

package/dist/env.js

@@ -41,8 +41,30 @@ export function resolveSmoodlyEnv(env, need = "site") {
         throw new Error("smoodly: SMOODLY_PUBLISHABLE_KEY is neither an sb_publishable_ key nor a JWT — copy the publishable (anon) key from your Supabase project.");
     }
     const url = env.SMOODLY_URL;
+    if (!/^https?:\/\/[^/\s]+/.test(url)) {
+        throw new Error(`smoodly: SMOODLY_URL "${url}" is not an http(s) address — copy the project URL from your Supabase project.`);
+    }
     return { url, secretKey, publishableKey, authUrl: env.SMOODLY_AUTH_URL || url, authKey: env.SMOODLY_AUTH_KEY || publishableKey };
 }
+let siteUrlWarned = false;
+/** 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
+ *  put localhost into every page's head. */
+export function siteUrl(env = process.env) {
+    const value = env.SITE_URL;
+    if (!value) {
+        if (env.NODE_ENV === "production" && !siteUrlWarned) {
+            siteUrlWarned = true;
+            console.warn(`smoodly: SITE_URL is not set — the page head's links point at http://localhost:3000 (Deploying: ${DEPLOYING}).`);
+        }
+        return new URL("http://localhost:3000");
+    }
+    if (!/^https?:\/\/[^/\s]+/.test(value)) {
+        throw new Error(`smoodly: SITE_URL "${value}" is not an http(s) address — set it like https://www.example.com.`);
+    }
+    return new URL(value);
+}
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
 export const smoodlyEnv = (need = "site") => resolveSmoodlyEnv(process.env, need);

package/dist/index.d.ts

@@ -129,7 +129,7 @@ export declare const smoodly: {
 };
 export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, BLANK_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.ts";
 export type { MarkNode, MarkPath, Marks, Scope } from "./marks.ts";
-export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig } from "./env.ts";
+export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig, siteUrl } from "./env.ts";
 export type { SmoodlyEnv, PresenceConfig } from "./env.ts";
 export { clientOptions, createSmoodlyClient } from "./client.ts";
 export { createSmoodlySite, pageContextOf } from "./site.ts";

package/dist/index.js

@@ -67,6 +67,6 @@ export const smoodly = {
     marks,
 };
 export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, BLANK_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.js";
-export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig } from "./env.js";
+export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig, siteUrl } from "./env.js";
 export { clientOptions, createSmoodlyClient } from "./client.js";
 export { createSmoodlySite, pageContextOf } from "./site.js";

package/dist/next/page-renderer.js

@@ -76,15 +76,19 @@ export function createPageRenderer(options) {
         }
         return _jsx(View, { entry: toEntryItem(hit.entry, hit.entry.fields, hit) });
     }
-    /** hreflang from the SAME map a language switch reads (spec 2026-09-15 §3): the locales with a URL, through href. */
-    function alternates(hit) {
+    /** The page's own address as its canonical, and hreflang from the SAME map a language switch reads
+     *  (spec 2026-09-15 §3): the locales with a URL, through href. Next makes both absolute from the
+     *  layout's `metadataBase` (tester run on 0.0.39, mission 6). */
+    function addresses(hit, locale) {
+        const own = hit.locales[locale]?.path;
+        const out = own ? { canonical: href(own, locale) } : {};
         if (site.locales.supported.length < 2)
-            return {};
+            return out;
         const languages = {};
-        for (const [locale, alt] of Object.entries(hit.locales))
+        for (const [l, alt] of Object.entries(hit.locales))
             if (alt?.path)
-                languages[locale] = href(alt.path, locale);
-        return { alternates: { languages } };
+                languages[l] = href(alt.path, l);
+        return { ...out, languages };
     }
     // Next's cacheComponents serves the catch-all from a fallback shell that
     // commits 200 before the page renders, so 404s and 308s are lost (spec
@@ -137,7 +141,13 @@ export function createPageRenderer(options) {
             return {};
         // A page type without seo: true still gets its page title as <title>; seo: true adds the panel's values on top.
         const seo = hit.seo ?? (hit.kind === "page" ? { title: hit.title } : undefined);
-        return { ...metadataFromSeo(seo), ...alternates(hit) };
+        const meta = metadataFromSeo(seo);
+        const { canonical, languages } = addresses(hit, locale);
+        // og:url only beside Open Graph values the page already sets: an openGraph of its own would
+        // replace the layout's defaults (Next merges metadata one key deep).
+        if (canonical && meta.openGraph)
+            meta.openGraph = { ...meta.openGraph, url: canonical };
+        return canonical || languages ? { ...meta, alternates: { ...(canonical ? { canonical } : {}), ...(languages ? { languages } : {}) } } : meta;
     }
     const any = () => true;
     /** The escape hatch may only render ITS OWN registration's record. */

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/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.38";
+export declare const SMOODLY_VERSION = "0.0.40";

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.38";
+export const SMOODLY_VERSION = "0.0.40";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "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": {