smoodly 0.0.35 → 0.0.36

package/README.md

@@ -523,6 +523,22 @@ Implemented:
   (the rule table, both adapters), the store contracts, `admin-ops`
   ("redirects on rename and move", "redirects ops"),
   `next-page-renderer` ("redirects"), `examples/site/e2e/redirects.spec.ts`.
+- Content API contract (spec 2026-09-29 content API contract): every
+  read returns the public shape — `EntryItem`, `PageItem`, `GlobalItem`
+  (`src/read-shapes.ts`), nothing of other locales, pointers or editors
+  leaves the site layer; a reference resolves as `{ id, path, fields }`
+  as deep as its field says, in lists and single reads alike, and the
+  types follow the depth; `smoodly_list_entries` (schema version 7)
+  filters, orders and limits over the snapshot shown, so `where` sees
+  localized fields and never the live row; a list is tagged by every
+  collection it resolved into; `seo: true` or `{ description, image }`
+  on a collection adds the SEO & Social panel, stored per locale under
+  `$seo` (`src/seo.ts`); every content table admits a write key only, the
+  publishable key serves sign-in and presence (`presenceConfig`). Tests:
+  `test/entry-store-contract.ts` ("query"), `test/site.test.tsx`,
+  `test/next-queries.test.tsx`, `test/types-refs.test.ts`,
+  `test/seo.test.ts`, `test/isolation.supabase.test.ts`,
+  `test/rls.supabase.test.ts`.
 - Editor safety (spec 2026-09-27 editor safety): schema drift — stored
   content the code no longer describes — is found by one pure walk
   (`admin/drift.ts`) over the serialized registry. Broken findings
@@ -692,31 +708,7 @@ goes straight into its bucket. Design-level questions live in
 
 ### Now
 
-- SEO for entry pages: entries have no `meta`; a `titleField`-based
-  title and a description field are the next step. *(2026-09-10, page fields and SEO)*
-- `where` filters a versioned collection's LIVE row, not its published
-  snapshot: an entry whose published version had `kind: "x"` and whose
-  draft changed it to `"y"` drops out of `where: { kind: "x" }` before
-  the change is published. The published gate is per locale row, the
-  filter is on the node's shared fields. Fix by filtering the snapshot
-  (a join on the version row) or by documenting that a versioned
-  collection's shared fields are live for filtering. *(2026-09-11, queries)*
-- `getEntries`/`getEntriesTree` return refs as ids (cheap lists); `getEntry`
-  by path resolves them, `getEntry` by id or slug does not — document or
-  unify when a site needs resolved lists. Worse than it reads: the field
-  types promise resolved objects everywhere (`f.ref` builds
-  `Resolved<T>`), and `guides/collections/queries.mdx` says `getEntry`
-  "by id or by its URL path" resolves references, so a developer's code
-  typechecks and fails at runtime. Decide the rule and make the types,
-  the runtime and the guide agree. *(2026-09-05; raised to Now 2026-09-29)*
-- The read API returns the site layer's shapes unprojected: `getEntries`
-  gives `{ entry: EntryRecord, path }` (the locales map, sort, parentId,
-  collection and timestamps ride along under `entry`), `getPage` gives
-  the renderer's `SitePage` (`record`, `tree`). Project in `queries.ts`,
-  at the public boundary, to `{ id, path, fields, updatedAt }` per entry
-  and a page without renderer internals; the tree item is already lean.
-  Do it before the Astro glue (OQ 29) wraps the same reads and before
-  a second site depends on the shape — it is a breaking change to `q`. *(2026-09-11, queries)*
+Nothing open.
 
 ### Next
 
@@ -1199,13 +1191,17 @@ goes straight into its bucket. Design-level questions live in
 
 #### Queries (`q`)
 
-- The read client over the read key (DESIGN.md OQ 31) can reuse `publicContent()`. *(2026-09-26, concurrency)*
-- `where` on localized fields (a join on the locale row), ranges and
-  negation; any-of over an array-valued field (any-of compares the text
-  form of the field, so it covers selects, refs and numbers; on a
-  checkboxes, refList or list field `site.getEntries` refuses it rather
-  than match nothing — both adapters agree on the text form, so a
-  one-element array never matches its element). *(2026-09-11, queries)*
+- `presence()` serves the presence channel only; a future read gateway (DESIGN.md OQ 31) is not built on it — no key but a write key reads content. *(2026-09-26, concurrency; 2026-09-30 §8)*
+- `where` ranges and negation. *(2026-09-11, queries)*
+- `EntryItem.updatedAt`, and `order: updatedAt`, read the LIVE locale row, so a draft autosave bumps the public timestamp and can reorder a public list; read the published version's `saved_at` for published reads. *(2026-09-30, content API contract final review)*
+- The bare-slug `getEntry` fallback re-reads the whole collection and resolves every entry's references and media before matching one slug; match on `record` first, then resolve only the hit (or query by slug). *(2026-09-30, content API contract final review)*
+- `SmoodlySite.resolve` (and `load`) still return the full `EntryRecord` (every locale, `updatedBy`) on the object the developer holds; the types are unexported and the spec calls it internal — mark it `@internal` or move both off the public interface. *(2026-09-30, content API contract final review)*
+- A nested `.resolve({ a: { b: true } })` types only the top level (`Rebase<V, keyof P>`) while the runtime resolves deeper; type the nesting. *(2026-09-30, content API contract final review)*
+- Any-of over an array-valued field: any-of compares the text form of
+  the field, so it covers selects, refs and numbers; on a checkboxes,
+  refList or list field `site.getEntries` refuses it rather than match
+  nothing — both adapters agree on the text form, so a one-element array
+  never matches its element. *(2026-09-11, queries)*
 - `getEntriesTree` has no `q` counterpart yet; add one when a site
   needs a nested collection nav. *(2026-09-11, queries)*
 - `getShared(["header", "footer", "contact"], { locale })` returning a
@@ -1278,12 +1274,10 @@ goes straight into its bucket. Design-level questions live in
   locale's cached unit of that page (spec 2026-09-06 §4). A
   `page:<id>:<locale>` tag would halve the revalidations on a bilingual
   site. *(2026-09-06)*
+- Examples and guides write `url(entry.path!)`: `path` is `string | null` on every entry, though a collection that declares `path` always has one — type it `string` for those and drop the assertions. *(2026-09-30, content API contract final review)*
 - `smoodlyMetadata` does not apply the registration check `renderSmoodlyPath`
   applies: a record whose `template` has no registration is a 404 body with
   its meta emitted beside it. *(2026-09-05)*
-- The entry-page view receives the whole `EntryRecord`, every locale's
-  row in `locales` included (fields, slug, status and version pointers); a
-  client entry page would ship all of it to the browser. *(2026-09-05)*
 
 #### Media
 
@@ -1439,9 +1433,6 @@ goes straight into its bucket. Design-level questions live in
   actor-free parts. *(2026-09-13, history)*
 - A GIN index on `entries.fields` when a customer's collection is large
   enough to need it; additive, no migration. *(2026-09-11, queries)*
-- `getEntry` by id goes through `site.getEntry`, which lists the whole
-  collection to find one row; a primary-key read first would be cheaper
-  on the uncached path (draft mode, first miss). *(2026-09-11, queries)*
 - Every revalidating op (publish, delete, a save of published content)
   answers with a fresh RSC render of the admin route — the layout's
   styles included, ~30 KB — because `updateTag` runs inside the server

package/dist/admin/drift.js

@@ -2,6 +2,7 @@ import { optionValues } from "../fields.js";
 import { isHidden } from "../conditions.js";
 import { allowedOf } from "../toolset.js";
 import { CUSTOM_NODE_TYPE } from "../custom/schema.js";
+import { SEO_KEY } from "../seo.js";
 import { CSS_KEY, GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY } from "../global.js";
 export const SEVERITY = {
     "unknown-section": "broken", "unknown-element": "broken", "unknown-shape": "broken", "unknown-collection": "broken",
@@ -209,7 +210,7 @@ export function pageDrift(registry, template, tree) {
     out.push(...holderDrift(registry, { scope: "page", name: shape.name }, "page.fields", { fields: tree.fields ?? {} }, { fields: shape.fields }));
     return out;
 }
-const RESERVED = new Set(["slug", SETTINGS_KEY, STYLES_KEY, CSS_KEY]);
+const RESERVED = new Set(["slug", SEO_KEY, SETTINGS_KEY, STYLES_KEY, CSS_KEY]);
 function localization(subject, descs, input, out) {
     if (!input.shared || !input.own)
         return;
@@ -231,7 +232,7 @@ export function entryDrift(registry, name, input) {
     const collection = registry.collections.find((c) => c.name === name);
     if (collection) {
         const subject = { scope: "collection", name };
-        const { slug: _slug, ...fields } = input.fields;
+        const { slug: _slug, [SEO_KEY]: _seo, ...fields } = input.fields;
         out.push(...holderDrift(registry, subject, "", { fields }, { fields: collection.fields }));
         localization(subject, collection.fields, input, out);
         return out;

package/dist/admin/editor/SeoSettings.d.ts

@@ -1,7 +1,13 @@
 export declare const SEO_TITLE_MAX = 60;
 export declare const SEO_DESCRIPTION_MAX = 160;
 export type SeoKey = "title" | "description" | "ogImage" | "noindex";
-export declare function SeoSettings({ meta, onPatch }: {
+export declare function SeoSettings({ meta, onPatch, titleHint, descriptionHint, imageHint }: {
     meta: Record<string, unknown>;
     onPatch(key: SeoKey, value: unknown): void;
+    /** What an empty title does; the page editor's default names the page title (an entry's names its title field). */
+    titleHint?: string;
+    /** What an empty description does, when it falls back on a field. */
+    descriptionHint?: string;
+    /** What an empty social image does, when it falls back on a field. */
+    imageHint?: string;
 }): import("react").JSX.Element;

package/dist/admin/editor/SeoSettings.js

@@ -8,8 +8,8 @@ const str = (v) => (typeof v === "string" ? v : "");
 function Counter({ n, max }) {
     return _jsxs("span", { className: n > max ? "sm-counter--over" : undefined, children: [n, "/", max] });
 }
-export function SeoSettings({ meta, onPatch }) {
+export function SeoSettings({ meta, onPatch, titleHint, descriptionHint, imageHint }) {
     const title = str(meta.title);
     const description = str(meta.description);
-    return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 14 }, children: [_jsx(Field, { label: "Title", counter: _jsx(Counter, { n: title.length, max: SEO_TITLE_MAX }), hint: "Used in search results and link previews. Empty: the page title.", children: _jsx("input", { className: "sm-input", value: title, onChange: (e) => onPatch("title", e.target.value) }) }), _jsx(Field, { label: "Description", counter: _jsx(Counter, { n: description.length, max: SEO_DESCRIPTION_MAX }), children: _jsx("textarea", { className: "sm-textarea", rows: 3, value: description, onChange: (e) => onPatch("description", e.target.value) }) }), _jsx(MediaWidget, { descriptor: { type: "image" }, value: meta.ogImage, onChange: (v) => onPatch("ogImage", v), label: "Social image", hint: "1200\u00D7630 recommended" }), _jsx(Field, { label: "Hide from search engines", asDiv: true, children: _jsx(Switch, { checked: meta.noindex === true, onChange: (v) => onPatch("noindex", v), label: "Hide from search engines" }) })] }));
+    return (_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 14 }, children: [_jsx(Field, { label: "Title", counter: _jsx(Counter, { n: title.length, max: SEO_TITLE_MAX }), hint: `Used in search results and link previews. ${titleHint ?? "Empty: the page title."}`, children: _jsx("input", { className: "sm-input", value: title, onChange: (e) => onPatch("title", e.target.value) }) }), _jsx(Field, { label: "Description", counter: _jsx(Counter, { n: description.length, max: SEO_DESCRIPTION_MAX }), hint: descriptionHint, children: _jsx("textarea", { className: "sm-textarea", rows: 3, value: description, onChange: (e) => onPatch("description", e.target.value) }) }), _jsx(MediaWidget, { descriptor: { type: "image" }, value: meta.ogImage, onChange: (v) => onPatch("ogImage", v), label: "Social image", hint: imageHint ? `1200×630 recommended. ${imageHint}` : "1200×630 recommended" }), _jsx(Field, { label: "Hide from search engines", asDiv: true, children: _jsx(Switch, { checked: meta.noindex === true, onChange: (v) => onPatch("noindex", v), label: "Hide from search engines" }) })] }));
 }

package/dist/admin/field-label.d.ts

@@ -0,0 +1,2 @@
+/** A key as a caption, sentence case: `spacingTop` → "Spacing top", `css` → "Custom CSS". */
+export declare const fieldLabel: (key: string) => string;

package/dist/admin/field-label.js

@@ -0,0 +1,2 @@
+/** A key as a caption, sentence case: `spacingTop` → "Spacing top", `css` → "Custom CSS". */
+export const fieldLabel = (key) => key === "css" ? "Custom CSS" : key.replace(/([A-Z])/g, (c) => ` ${c.toLowerCase()}`).replace(/^./, (c) => c.toUpperCase());

package/dist/admin/forms/FieldWidget.js

@@ -11,10 +11,10 @@ import { optionsOf } from "../../fields.js";
 import { isHidden } from "../../conditions.js";
 import { cssProblem } from "../../css.js";
 import { Button, Field, Switch } from "../ui/primitives.js";
+import { fieldLabel } from "../field-label.js";
 import { patchObject } from "./list.js";
 import { tidySlug } from "./slug-field.js";
-/** A key as a caption, sentence case: `spacingTop` → "Spacing top", `css` → "Custom CSS". */
-const label = (key) => key === "css" ? "Custom CSS" : key.replace(/([A-Z])/g, (c) => ` ${c.toLowerCase()}`).replace(/^./, (c) => c.toUpperCase());
+const label = fieldLabel;
 export function FieldWidget({ descriptor: d, value: valueProp, onChange, errors, path: pathProp, bare, refOptions, suggestions, fieldKey, prefix, mark, inlinePath, onEditHere, scope, emptyLabel, hint, onBlur, }) {
     const path = pathProp ?? fieldKey;
     // A tags field has no per-chip slot: the first item error shows under the field.

package/dist/admin/next/create-admin.d.ts

@@ -2,15 +2,15 @@ import type { ReactNode } from "react";
 import type { ResolvedConfig } from "../../config.ts";
 import type { AdminOpAction } from "../ops.ts";
 import type { AuthConfig } from "../shell/session.ts";
-import type { ContentConfig } from "../../env.ts";
-/** `content` (optional) is the content project's public config for editing presence (spec 2026-09-26
- *  concurrency §5), async because its space is asked of the database; absent or failed, presence
+import type { PresenceConfig } from "../../env.ts";
+/** `presence` (optional) is the content project's public config for editing presence (spec 2026-09-26
+ *  concurrency §5; presence only, never content reads, spec 2026-09-29 content API contract §8), async because its space is asked of the database; absent or failed, presence
  *  is off and everything else works. */
 export declare function createSmoodlyAdmin(input: {
     config: ResolvedConfig;
     op: AdminOpAction;
     auth: () => AuthConfig;
-    content?: () => ContentConfig | Promise<ContentConfig>;
+    presence?: () => PresenceConfig | Promise<PresenceConfig>;
 }): {
     AdminPage: () => null;
     AdminLayout: ({ children }: {

package/dist/admin/next/create-admin.js

@@ -2,8 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { serializeAdminConfig } from "../serialize.js";
 import { AdminApp } from "../shell/AdminApp.js";
 import { AdminStyles } from "../ui/theme.js";
-/** `content` (optional) is the content project's public config for editing presence (spec 2026-09-26
- *  concurrency §5), async because its space is asked of the database; absent or failed, presence
+/** `presence` (optional) is the content project's public config for editing presence (spec 2026-09-26
+ *  concurrency §5; presence only, never content reads, spec 2026-09-29 content API contract §8), async because its space is asked of the database; absent or failed, presence
  *  is off and everything else works. */
 export function createSmoodlyAdmin(input) {
     const registry = serializeAdminConfig(input.config);
@@ -28,14 +28,14 @@ export function createSmoodlyAdmin(input) {
         // Presence is the one thing that needs it: a failed lookup (an unmigrated project, an
         // unreachable database) is logged and turns presence off, so the shell still reaches
         // sign-in, the schema notice or the admin-path ErrorPane.
-        let content;
+        let presenceConfig;
         try {
-            content = await input.content?.();
+            presenceConfig = await input.presence?.();
         }
         catch (e) {
             console.error("smoodly: editing presence is off —", e instanceof Error ? e.message : e);
         }
-        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth(), content: content }), children] }));
+        return (_jsxs("div", { className: "sm-admin", suppressHydrationWarning: true, children: [_jsx(AdminStyles, {}), _jsx(AdminApp, { registry: registry, op: input.op, auth: input.auth(), presenceConfig: presenceConfig }), children] }));
     }
     return { AdminPage, AdminLayout };
 }

package/dist/admin/next/index.d.ts

@@ -4,5 +4,5 @@ export type { AdminOpCall, AdminOpAction, AdminOps, OpResult, MembersListResult
 export type { InviteInput, InviteResult, MemberRecord } from "../../member-store.ts";
 export type { MemberRole } from "../../permissions.ts";
 export type { AuthConfig } from "../shell/session.ts";
-export type { ContentConfig } from "../../env.ts";
+export type { PresenceConfig } from "../../env.ts";
 export type { AdminAuth } from "../auth.ts";

package/dist/admin/serialize.d.ts

@@ -34,6 +34,13 @@ export type AdminCollection = {
     depth: number;
     /** `order: "manual"` — the list drags into the `sort` order (spec 2026-09-09 §5). */
     manual: boolean;
+    /** The collection has SEO & Social values (spec 2026-09-29 content API contract §7); each label
+     *  names, in lower case, the field an empty value falls back on — the hints' copy. */
+    seo?: {
+        titleLabel: string;
+        descriptionLabel?: string;
+        imageLabel?: string;
+    };
 };
 export type AdminPageTemplate = {
     name: string;
@@ -45,7 +52,7 @@ export type AdminPageTemplate = {
     zones: Record<string, ZonePolicy>;
     /** The template's page fields (spec 2026-09-10 page fields §5), edited on the Settings tab. */
     fields: Record<string, AdminField>;
-    /** `meta: { seo: true }` — the SEO & Social tab exists for this template. */
+    /** `seo: true` — the SEO & Social tab exists for this template. */
     seo: boolean;
 };
 export type AdminGlobal = {

package/dist/admin/serialize.js

@@ -1,5 +1,7 @@
 import { fixedSlug } from "../page.js";
 import { collectionDepth, collectionOrder } from "../collections.js";
+import { SEO_KEY } from "../seo.js";
+import { fieldLabel } from "./field-label.js";
 import { perLocaleSegments } from "../paths.js";
 import { styleDescriptors } from "../styles.js";
 import { CUSTOM_NODE_TYPE, customFields, defaultRow } from "../custom/index.js";
@@ -32,6 +34,15 @@ export function sectionSettings(config, name) {
 function sectionCss(config, name) {
     return config.css && (config.registry.sections ?? []).find((s) => s.schema.name === name)?.schema.css !== false;
 }
+const lower = (key) => fieldLabel(key).toLowerCase();
+function seoLabels(c) {
+    const named = c.seo === true || c.seo === undefined ? {} : c.seo;
+    return {
+        titleLabel: c.titleField ? lower(c.titleField) : "entry title",
+        ...(named.description ? { descriptionLabel: lower(named.description) } : {}),
+        ...(named.image ? { imageLabel: lower(named.image) } : {}),
+    };
+}
 export function serializeAdminConfig(config) {
     const perLocale = (v) => perLocaleSegments(v, config.locales.supported);
     return {
@@ -62,12 +73,17 @@ export function serializeAdminConfig(config) {
                 sample: e.sample,
             };
         }),
-        collections: (config.registry.collections ?? []).map((c) => ({
-            name: c.name, title: c.title, titleField: c.titleField, fields: serializeMap(c.fields),
-            ...(c.path !== undefined ? { path: perLocale(c.path) } : {}),
-            depth: collectionDepth(c),
-            manual: collectionOrder(c) === "manual",
-        })),
+        collections: (config.registry.collections ?? []).map((c) => {
+            // `$seo` is the SEO panel's, never a form field.
+            const { [SEO_KEY]: _seo, ...fields } = c.fields;
+            return {
+                name: c.name, title: c.title, titleField: c.titleField, fields: serializeMap(fields),
+                ...(c.path !== undefined ? { path: perLocale(c.path) } : {}),
+                depth: collectionDepth(c),
+                manual: collectionOrder(c) === "manual",
+                ...(c.seo !== undefined ? { seo: seoLabels(c) } : {}),
+            };
+        }),
         pages: (config.registry.pages ?? [])
             .filter(({ schema }) => schema.kind === "page")
             .map(({ schema }) => {
@@ -80,7 +96,7 @@ export function serializeAdminConfig(config) {
                 ...(typeof p.slug === "object" && p.slug !== null ? { slugs: { ...p.slug } } : {}),
                 zones: p.zones ?? {},
                 fields: serializeMap(p.fields),
-                seo: p.meta?.seo === true,
+                seo: p.seo === true,
             };
         }),
         globals: (config.registry.globals ?? []).map((s) => ({

package/dist/admin/shell/AdminApp.d.ts

@@ -1,10 +1,10 @@
 import type { AdminOpAction } from "../ops.ts";
 import type { AdminRegistry } from "../serialize.ts";
 import { type AuthConfig } from "./session.ts";
-import type { ContentConfig } from "../../env.ts";
-export declare function AdminApp({ registry, op, auth, content }: {
+import type { PresenceConfig } from "../../env.ts";
+export declare function AdminApp({ registry, op, auth, presenceConfig }: {
     registry: AdminRegistry;
     op: AdminOpAction;
     auth: AuthConfig;
-    content?: ContentConfig;
+    presenceConfig?: PresenceConfig;
 }): import("react").JSX.Element;

package/dist/admin/shell/AdminApp.js

@@ -39,7 +39,7 @@ import { schemaBehind } from "../../schema-version.js";
 import { createPresence, followTokenRefresh } from "./presence.js";
 import { connectRealtime } from "./presence-realtime.js";
 import { PresenceProvider } from "./presence-context.js";
-export function AdminApp({ registry, op, auth, content }) {
+export function AdminApp({ registry, op, auth, presenceConfig }) {
     const session = useAdminSession(auth);
     const [ops] = useState(() => makeClientOps(op, session.token));
     const route = useRoute(registry.adminPath);
@@ -89,7 +89,7 @@ export function AdminApp({ registry, op, auth, content }) {
     const tokenRef = useRef(session.token);
     tokenRef.current = session.token;
     const authClient = session.client;
-    const contentUrl = content?.url, contentKey = content?.key, contentSpace = content?.spaceId;
+    const contentUrl = presenceConfig?.url, contentKey = presenceConfig?.key, contentSpace = presenceConfig?.spaceId;
     useEffect(() => {
         if (!signedIn || !contentUrl || !contentKey || !contentSpace || !email) {
             setPresence(null);

package/dist/admin/shell/EntryForm.js

@@ -49,6 +49,8 @@ import { usePresence, usePresenceState, useSavedElsewhere, useTrackPresence } fr
 import { editorsOf } from "./presence.js";
 import { PresenceLine } from "../ui/PresenceLine.js";
 import { slugHint, tidySlug, withFollowingSlug } from "../forms/slug-field.js";
+import { SeoSettings } from "../editor/SeoSettings.js";
+import { SEO_KEY } from "../../seo.js";
 /** A stable empty map for the hooks that run before the "no such collection" return. */
 const NO_FIELDS = {};
 /** True while the entry's slug box has focus: its field wrapper carries the path. */
@@ -478,5 +480,10 @@ export function EntryForm({ ops, registry, collection, id }) {
                                             setDirty(true);
                                             setTouched(true);
                                             mark();
-                                        } })] })) : !notice && _jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" })] }), _jsx(ResizeHandle, {}), _jsxs("aside", { className: "sm-inspector", children: [record && row && (_jsxs("div", { className: "sm-card", children: [_jsx(SectionLabel, { children: "Document info" }), _jsx(InfoRow, { label: "Created", value: relativeTime(record.createdAt) }), _jsx(InfoRow, { label: "Updated", value: updatedLine(row.updatedAt, row.updatedBy) }), (redirects[locale] ?? []).length > 0 && _jsx(InfoRow, { label: "Redirects from", value: redirects[locale].join(", "), mono: true }), multilingual && _jsx(InfoRow, { label: "Languages", value: Object.keys(record.locales).join(", ") }), _jsx(InfoRow, { label: "ID", value: id, mono: true })] })), record && (_jsxs("div", { className: "sm-card", children: [multilingual && row && Object.keys(record.locales).length > 1 && (_jsxs(Button, { variant: "secondary", onClick: () => void doRemoveLocale(), children: ["Remove from ", locale] })), _jsx(Button, { variant: "danger", onClick: destroy, children: "Delete" })] }))] })] })] }));
+                                        } })] })) : !notice && _jsx("p", { style: { color: "var(--text-muted)" }, children: "Loading\u2026" })] }), _jsx(ResizeHandle, {}), _jsxs("aside", { className: "sm-inspector", children: [record && row && (_jsxs("div", { className: "sm-card", children: [_jsx(SectionLabel, { children: "Document info" }), _jsx(InfoRow, { label: "Created", value: relativeTime(record.createdAt) }), _jsx(InfoRow, { label: "Updated", value: updatedLine(row.updatedAt, row.updatedBy) }), (redirects[locale] ?? []).length > 0 && _jsx(InfoRow, { label: "Redirects from", value: redirects[locale].join(", "), mono: true }), multilingual && _jsx(InfoRow, { label: "Languages", value: Object.keys(record.locales).join(", ") }), _jsx(InfoRow, { label: "ID", value: id, mono: true })] })), record && row && meta.seo && (_jsxs("div", { className: "sm-card", children: [_jsx(SectionLabel, { children: "SEO & Social" }), _jsx(SeoSettings, { meta: fields?.[SEO_KEY] ?? {}, titleHint: `Empty: the ${meta.seo.titleLabel}.`, descriptionHint: meta.seo.descriptionLabel ? `Empty: the ${meta.seo.descriptionLabel}.` : undefined, imageHint: meta.seo.imageLabel ? `Empty: the ${meta.seo.imageLabel}.` : undefined, onPatch: (key, value) => {
+                                            setFields((f) => ({ ...(f ?? {}), [SEO_KEY]: { ...(f?.[SEO_KEY] ?? {}), [key]: value } }));
+                                            setDirty(true);
+                                            setTouched(true);
+                                            mark();
+                                        } })] })), record && (_jsxs("div", { className: "sm-card", children: [multilingual && row && Object.keys(record.locales).length > 1 && (_jsxs(Button, { variant: "secondary", onClick: () => void doRemoveLocale(), children: ["Remove from ", locale] })), _jsx(Button, { variant: "danger", onClick: destroy, children: "Delete" })] }))] })] })] }));
 }

package/dist/admin/shell/presence-realtime.d.ts

@@ -1,3 +1,3 @@
-import type { ContentConfig } from "../../env.ts";
+import type { PresenceConfig } from "../../env.ts";
 import type { PresenceChannel } from "./presence.ts";
-export declare function connectRealtime(config: ContentConfig, email: string, token: string): PresenceChannel;
+export declare function connectRealtime(config: PresenceConfig, email: string, token: string): PresenceChannel;

package/dist/cli/space-io.js

@@ -47,7 +47,7 @@ export async function readSchemaVersion(db) {
 }
 export function schemaRefusal(missing, command) {
     return missing === "key"
-        ? `${command} needs SMOODLY_SECRET_KEY — the service-role key, or the cloud's write key. The publishable key sees published content only.`
+        ? `${command} needs SMOODLY_SECRET_KEY — the service-role key, or the cloud's write key. The publishable key reads no content.`
         : "This database has no Smoodly schema. Run `npx smoodly migrate`, then `supabase db push` (hosted) or `supabase db reset` (local).";
 }
 /** 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/collections.d.ts

@@ -1,5 +1,6 @@
 import type { Descriptor } from "./fields.ts";
 import type { BuilderMap, NamespaceValues } from "./schema.ts";
+import { type CollectionSeo } from "./seo.ts";
 /** How a collection is ordered — in the admin list and in public reads
  *  alike (spec 2026-09-05 §3). "manual" is the drag order (`sort`). */
 export type EntryOrder = "manual" | {
@@ -29,6 +30,8 @@ export type CollectionSchema<F extends BuilderMap = BuilderMap, N extends string
     admin?: {
         listColumns?: string[];
     };
+    /** Entries carry SEO & Social values (spec 2026-09-29 content API contract §7): stored under `$seo`, empty values falling back on `titleField` and the named fields. */
+    seo?: CollectionSeo;
     /** phantom: the entry value shape, used by f.ref target inference */
     readonly __entry?: NamespaceValues<F>;
 };
@@ -47,4 +50,5 @@ export declare function collection<F extends BuilderMap, const N extends string
     admin?: {
         listColumns?: string[];
     };
+    seo?: CollectionSeo;
 }): CollectionSchema<F, N>;

package/dist/collections.js

@@ -1,3 +1,4 @@
+import { SEO_DESCRIPTOR, SEO_KEY, validateCollectionSeo } from "./seo.js";
 export const DEFAULT_ORDER = { by: "createdAt", direction: "desc" };
 export const BUILT_IN_ORDER_FIELDS = ["createdAt", "updatedAt"];
 export const collectionOrder = (c) => c.order ?? DEFAULT_ORDER;
@@ -7,6 +8,9 @@ export function collection(input) {
         throw new Error("smoodly: a collection requires a name.");
     if (["global", "asset", "media"].includes(input.name))
         throw new Error(`smoodly: "${input.name}" is a reserved name.`);
+    if (Object.prototype.hasOwnProperty.call(input.fields, SEO_KEY)) {
+        throw new Error(`smoodly: collection "${input.name}": "${SEO_KEY}" is a reserved key.`);
+    }
     if (input.tree !== undefined && (!Number.isInteger(input.tree.depth) || input.tree.depth < 1)) {
         throw new Error(`smoodly: collection "${input.name}" declares an invalid tree depth.`);
     }
@@ -49,12 +53,16 @@ export function collection(input) {
             throw new Error(`smoodly: collection "${input.name}" slug field "${key}" follows an unknown field "${from}".`);
         }
     }
+    const fields = Object.fromEntries(Object.entries(input.fields).map(([k, b]) => [k, b.descriptor]));
+    if (input.seo !== undefined)
+        validateCollectionSeo(input.name, input.seo, fields);
     return {
         kind: "collection",
         name: input.name,
         title: input.title,
         titleField: input.titleField,
-        fields: Object.fromEntries(Object.entries(input.fields).map(([k, b]) => [k, b.descriptor])),
+        fields: input.seo !== undefined ? { ...fields, [SEO_KEY]: SEO_DESCRIPTOR } : fields,
+        ...(input.seo !== undefined ? { seo: input.seo } : {}),
         ...(input.path !== undefined ? { path: input.path } : {}),
         ...(input.tree !== undefined ? { tree: input.tree } : {}),
         ...(input.order !== undefined ? { order: input.order } : {}),

package/dist/entry-page.d.ts

@@ -1,21 +1,23 @@
 import type { ComponentType, ReactElement } from "react";
 import type { CollectionSchema } from "./collections.ts";
-import type { EntryRecord } from "./entry-store.ts";
-import type { LocaleAlternate } from "./paths.ts";
+import type { EntryItem } from "./read-shapes.ts";
+import type { Materialize } from "./schema.ts";
 export type EntryPageSchema = {
     kind: "entryPage";
     name: string;
     collection: string;
 };
-/** What an entry page renders: the entry in the render locale, its path
- *  there, and its address in every supported locale (spec 2026-09-15 §1). */
-export type EntryPageProps = {
-    entry: EntryRecord;
-    path: string;
-    locale: string;
-    locales: Record<string, LocaleAlternate | null>;
+/** What an entry page renders: the entry as a read returns it — its path, locale and
+ *  locale alternates ride on it (spec 2026-09-29 content API contract §3). */
+export type EntryPageProps<F = Record<string, unknown>> = {
+    entry: EntryItem<F>;
 };
 export type PairedEntryPage = ((props: EntryPageProps) => ReactElement) & {
     schema: EntryPageSchema;
 };
-export declare function entryPage(collection: CollectionSchema<any>, View: ComponentType<EntryPageProps>): PairedEntryPage;
+/** The collection's fields as a read returns them. */
+type Materialized<C extends CollectionSchema<any>> = {
+    [K in keyof NonNullable<C["__entry"]>]: Materialize<NonNullable<C["__entry"]>[K]>;
+};
+export declare function entryPage<C extends CollectionSchema<any>>(collection: C, View: ComponentType<EntryPageProps<Materialized<C>>>): PairedEntryPage;
+export {};

package/dist/entry-store.d.ts

@@ -81,6 +81,22 @@ export type ListOptions = {
      */
     parent?: string | null;
 };
+export type SnapshotQuery = {
+    locale: string;
+    /** true: the live row (the editor preview); false: the published snapshot. */
+    draft: boolean;
+    where?: Where;
+    order?: EntryOrder;
+    limit?: number;
+    parent?: string | null;
+    /** Only these entries (getEntry by id). */
+    ids?: string[];
+};
+/** `fields` is the merged snapshot (shared, localized, `slug`) of the version shown; `record` never leaves the site layer. */
+export type SnapshotRow = {
+    record: EntryRecord;
+    fields: Record<string, unknown>;
+};
 export type CreateEntryOptions = {
     locale: string;
     parentId?: string | null;
@@ -102,6 +118,11 @@ 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[]>;
+    /** Filters, orders and limits over the version SHOWN: the published snapshot (a row
+     *  without one falls back to the live merge), or the live row when `draft` (spec
+     *  2026-09-29 content API contract §5). Only rows present in `locale`; the published
+     *  path also needs the row published. */
+    query(collection: string, q: SnapshotQuery): Promise<SnapshotRow[]>;
     /** 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
@@ -168,6 +189,8 @@ export interface EntryStore {
     }[]>;
     resolvePath(locale: string, path: string): Promise<PathHit | null>;
     pathsOf(collection: string, id: string): Promise<Record<string, string>>;
+    /** id → full live path in `locale` for many entries of one collection; ids without one are absent. */
+    pathsIn(collection: string, ids: string[], locale: string): Promise<Record<string, string>>;
     /** locale → this entry's old addresses. */
     redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
 }
@@ -239,6 +262,10 @@ export declare function entryTitleIn(record: EntryRecord, locale: string, schema
  * follow-ups for the mixed-type and JSON-null edges.
  */
 export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
+/** Comparator for `query`: like compareEntries, but a declared field reads the
+ *  merged snapshot, `updatedAt` the locale row's, and an absent, null or empty-string value
+ *  sorts last in both directions; ties break by creation order (ascending). */
+export declare function compareSnapshots(order: EntryOrder, locale: string, seq: (id: string) => number): (a: SnapshotRow, b: SnapshotRow) => number;
 export declare class MemoryEntryStore implements EntryStore {
     private refs;
     private entries;
@@ -287,6 +314,7 @@ export declare class MemoryEntryStore implements 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[]>;
+    query(collection: string, q: SnapshotQuery): Promise<SnapshotRow[]>;
     getMany(collection: string, ids: string[], locale: string, options?: {
         status?: "published";
     }): Promise<Record<string, Record<string, unknown>>>;
@@ -315,6 +343,7 @@ export declare class MemoryEntryStore implements EntryStore {
         sourceId: string;
     }[]>;
     resolvePath(locale: string, path: string): Promise<PathHit | null>;
+    pathsIn(collection: string, ids: string[], locale: string): Promise<Record<string, string>>;
     pathsOf(collection: string, id: string): Promise<{}>;
     redirectsOf(collection: string, id: string): Promise<Record<string, string[]>>;
 }