smoodly 0.0.34 → 0.0.36

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[]>>;
 }

package/dist/entry-store.js

@@ -172,6 +172,32 @@ export function compareEntries(order, seq) {
         return d !== 0 ? d * dir : (seq(a) - seq(b)) * dir;
     };
 }
+/** 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 function compareSnapshots(order, locale, seq) {
+    return (a, b) => {
+        if (order === "manual") {
+            const d = (a.record.sort ?? Infinity) - (b.record.sort ?? Infinity);
+            return d !== 0 ? d : seq(a.record.id) - seq(b.record.id);
+        }
+        const dir = order.direction === "asc" ? 1 : -1;
+        const value = (r) => order.by === "createdAt" ? r.record.createdAt : order.by === "updatedAt" ? r.record.locales[locale]?.updatedAt : r.fields[order.by];
+        const empty = (v) => (v === "" ? undefined : v); // a cleared text or date is empty too
+        const va = empty(value(a)), vb = empty(value(b));
+        const tie = seq(a.record.id) - seq(b.record.id);
+        if (order.by === "createdAt")
+            return tie * dir; // the clock can tie within a millisecond; creation order cannot
+        if (va == null && vb == null)
+            return tie;
+        if (va == null)
+            return 1;
+        if (vb == null)
+            return -1;
+        const d = typeof va === "number" && typeof vb === "number" ? va - vb : String(va).localeCompare(String(vb));
+        return d !== 0 ? d * dir : tie;
+    };
+}
 export class MemoryEntryStore {
     constructor(collections, 
     // pass the SAME index to MemoryPageStore so cross-kind questions work
@@ -389,6 +415,29 @@ export class MemoryEntryStore {
             rows = rows.slice(0, options.limit);
         return rows.map((e) => this.snapshot(e));
     }
+    async query(collection, q) {
+        const schema = this.schema(collection);
+        const wanted = q.ids ? new Set(q.ids) : null;
+        const rows = [];
+        for (const e of this.entries.values()) {
+            if (e.collection !== collection)
+                continue;
+            if (wanted && !wanted.has(e.id))
+                continue;
+            if (q.parent !== undefined && e.parentId !== q.parent)
+                continue;
+            const row = e.locales[q.locale];
+            if (!row || (!q.draft && row.status !== "published"))
+                continue;
+            const snapshot = !q.draft && row.publishedVersionId ? this.versions.get(row.publishedVersionId) : undefined;
+            const fields = snapshot ? structuredClone(snapshot.fields) : entryFieldsIn(e, q.locale);
+            if (q.where && !matchesWhere(fields, q.where))
+                continue;
+            rows.push({ record: this.snapshot(e), fields });
+        }
+        rows.sort(compareSnapshots(q.order ?? collectionOrder(schema), q.locale, (id) => this.order.get(id)));
+        return typeof q.limit === "number" ? rows.slice(0, q.limit) : rows;
+    }
     async getMany(collection, ids, locale, options) {
         this.schema(collection);
         const out = {};
@@ -644,6 +693,10 @@ export class MemoryEntryStore {
     resolvePath(locale, path) {
         return this.paths.resolve(locale, path);
     }
+    pathsIn(collection, ids, locale) {
+        this.schema(collection);
+        return this.paths.livePathsIn("entry", ids, locale);
+    }
     pathsOf(collection, id) {
         return this.row(collection, id) ? this.paths.pathsOf({ kind: "entry", id }) : Promise.resolve({});
     }

package/dist/env.d.ts

@@ -4,7 +4,7 @@ export type SmoodlyEnv = {
     url: string;
     /** Server-only: the service-role key (self-host) or the environment's write key (cloud). */
     secretKey: string;
-    /** What a browser may hold for the content project: anon/publishable key, or the read key. */
+    /** What a browser may hold for the content project: anon/publishable key, or the cloud's per-environment key. It reads no content (sign-in and presence only). */
     publishableKey: string;
     /** Where editors sign in. Defaults to `url`. */
     authUrl: string;
@@ -15,12 +15,12 @@ export declare function resolveSmoodlyEnv(env: Record<string, string | undefined
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
 export declare const smoodlyEnv: () => SmoodlyEnv;
-/** What the browser needs to join the content project's presence channel (spec 2026-09-26 concurrency §5): public values only. */
-export type ContentConfig = {
+/** What the browser needs to join the admin's presence channel: the content project's URL, publishable key and space, public values only — never for content reads (spec 2026-09-29 content API contract §8). */
+export type PresenceConfig = {
     url: string;
     key: string;
     spaceId: string;
 };
-/** The public config, with the space the database says the secret key acts in —
+/** The presence config, with the space the database says the secret key acts in —
  *  asked, never read out of the key, so it cannot disagree with where rows land. */
-export declare function publicContentConfig(env: SmoodlyEnv, db?: Parameters<typeof readCurrentSpace>[0]): Promise<ContentConfig>;
+export declare function presenceConfig(env: SmoodlyEnv, db?: Parameters<typeof readCurrentSpace>[0]): Promise<PresenceConfig>;

package/dist/env.js

@@ -25,9 +25,9 @@ export const smoodlyEnv = () => resolveSmoodlyEnv(process.env);
 /** One lookup per process per content project and key: the space never
  *  changes for a key. A failed lookup is not cached, so the next call retries. */
 const spaces = new Map();
-/** The public config, with the space the database says the secret key acts in —
+/** The presence config, with the space the database says the secret key acts in —
  *  asked, never read out of the key, so it cannot disagree with where rows land. */
-export function publicContentConfig(env, db) {
+export function presenceConfig(env, db) {
     const cacheKey = `${env.url}\n${env.secretKey}`;
     let space = spaces.get(cacheKey);
     if (!space) {

package/dist/fields.d.ts

@@ -24,6 +24,14 @@ export declare function normalizeOptions<V extends string>(options: readonly Opt
 export declare function optionsOf(options: unknown): Option[];
 /** The values a stored choice may take. */
 export declare const optionValues: (options: unknown) => string[];
+/** A ref field's value at the type level: the target and how deep the ref site resolves it.
+ *  Never a runtime value — `Values<M>` turns it into what a read returns. */
+export type RefMode = "shallow" | "full" | (string & {});
+export type RefTo<T, M extends RefMode = "shallow"> = {
+    readonly __refTo: T;
+    readonly __mode: M;
+};
+type Rebase<V, M extends RefMode> = V extends RefTo<infer T, any> ? RefTo<T, M> : V extends RefTo<infer T, any>[] ? RefTo<T, M>[] : V;
 export type FieldBuilder<Value = unknown, Flags extends BuilderFlags = {}> = {
     readonly descriptor: Descriptor;
     optional(): FieldBuilder<Value, Flags & {
@@ -43,7 +51,9 @@ export type FieldBuilder<Value = unknown, Flags extends BuilderFlags = {}> = {
      *   the named refs, one level; object values nest deeper
      * - no call — hydrate the entry itself; its refs stay ids
      */
-    resolve(...projection: (string | Record<string, unknown>)[]): FieldBuilder<Value, Flags>;
+    resolve(): FieldBuilder<Rebase<Value, "full">, Flags>;
+    resolve<const K extends string>(...keys: K[]): FieldBuilder<Rebase<Value, K>, Flags>;
+    resolve<const P extends Record<string, unknown>>(projection: P): FieldBuilder<Rebase<Value, keyof P & string>, Flags>;
     /** Hide the field while the condition holds (spec 2026-09-14 §12): it leaves the form and validation skips it; the stored value is kept. */
     hidden(condition: Condition): FieldBuilder<Value, Flags>;
     /** phantom, type-level only */
@@ -105,14 +115,10 @@ export declare const f: {
      *  300px sidebar cannot show one legibly (spec 2026-09-07, list field §1).
      *  `.min`/`.max` count items. */
     list: <B extends FieldBuilder<any, any>>(item: B & NotLocalized<B>) => FieldBuilder<ValueOf<B>[], {}>;
-    ref: <T>(target: () => T) => FieldBuilder<Resolved<T>, {}>;
-    refList: <T>(target: () => T) => FieldBuilder<Resolved<T>[], {}>;
+    ref: <T>(target: () => T) => FieldBuilder<RefTo<T, "shallow">, {}>;
+    refList: <T>(target: () => T) => FieldBuilder<RefTo<T, "shallow">[], {}>;
 };
 export type ValueOf<B> = B extends FieldBuilder<infer V, infer Flags> ? Flags extends {
     optional: true;
 } ? V | undefined : V : never;
-/** Resolved entry for a ref target — refined when collections land. */
-export type Resolved<T> = T extends {
-    __entry?: infer E;
-} ? E : Record<string, unknown>;
 export {};

package/dist/fields.js

@@ -37,13 +37,13 @@ function builder(descriptor) {
         max: (n) => chain({ max: n }),
         min: (n) => chain({ min: n }),
         default: (v) => chain({ default: v }),
-        resolve: (...projection) => {
+        resolve: ((...projection) => {
             if (projection.length === 0)
                 return chain({ resolve: "full" });
             if (typeof projection[0] === "object")
                 return chain({ resolve: projection[0] });
             return chain({ resolve: Object.fromEntries(projection.map((k) => [k, true])) });
-        },
+        }),
         hidden: (condition) => chain({ hidden: condition }),
     };
 }

package/dist/global.d.ts

@@ -1,8 +1,8 @@
 import type { CollectionSchema } from "./collections.ts";
 import type { Descriptor } from "./fields.ts";
 import type { PairedComponent } from "./pairing.tsx";
-import type { BuilderMap, NamespaceValues, SectionSchema } from "./schema.ts";
-import type { StyleProps } from "./styles.ts";
+import type { BuilderMap, SectionSchema, Values } from "./schema.ts";
+import type { GlobalItem, VisualGlobalItem } from "./read-shapes.ts";
 /** The reserved tree node type of a placement. */
 export declare const GLOBAL_NODE_TYPE = "global";
 /** The reserved keys a visual item's settings, styles steps and css live under in its row (spec 2026-09-14 §8). */
@@ -46,12 +46,9 @@ type GlobalInput<N extends string = string> = {
 export declare function globalItem<F extends BuilderMap, const N extends string = string>(input: GlobalInput<N> & {
     fields: F;
     section?: undefined;
-}): GlobalSchema<NamespaceValues<F>, N>;
+}): GlobalSchema<GlobalItem<Values<F>>, N>;
 export declare function globalItem<F extends BuilderMap, St extends BuilderMap, const N extends string = string>(input: GlobalInput<N> & {
     section: PairedComponent<SectionSchema<F, St>, F, St>;
     fields?: undefined;
-}): GlobalSchema<NamespaceValues<F> & {
-    settings: NamespaceValues<St>;
-    styles: StyleProps;
-}, N>;
+}): GlobalSchema<VisualGlobalItem<Values<F>, Values<St>>, N>;
 export {};

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, EntryScan, 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, SnapshotQuery, SnapshotRow, } 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";
@@ -66,7 +66,10 @@ export type { PageStore, PageRecord, PageLocale, PageVersion, PageScan, PageStor
 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";
-export type { SectionSchema, ElementSchema, BuilderMap } from "./schema.ts";
+export type { SectionSchema, ElementSchema, BuilderMap, Values } from "./schema.ts";
+export type { CollectionSeo } from "./seo.ts";
+export type { EntryRef, EntryItem, PageItem, GlobalItem, VisualGlobalItem, Seo } from "./read-shapes.ts";
+export type { RefTo } from "./fields.ts";
 export type { Props, PairedComponent } from "./pairing.tsx";
 export type { CollectionSchema, EntryOrder } from "./collections.ts";
 export { DEFAULT_TOOLSET, type Toolset, type ToolsetMark, type ToolsetNode } from "./toolset.ts";
@@ -94,23 +97,7 @@ export declare const smoodly: {
                 omit: string[];
             };
             css?: false;
-            sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K : never : never; }[keyof F]>]: import("./fields.ts").ValueOf<F[K_1]>; } & { [K_2 in { [K in keyof F]: F[K] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K : never : never; }[keyof F]]?: import("./fields.ts").ValueOf<F[K_2]> | undefined; } & { [K_4 in Exclude<keyof S, { [K_3 in keyof S]: S[K_3] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K_3 : never : never; }[keyof S]>]: import("./fields.ts").ValueOf<S[K_4]>; } & { [K_5 in { [K_3 in keyof S]: S[K_3] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
+            sample?: Partial<{ [K in keyof import("./schema.ts").NamespaceValues<F>]: import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<F>[K]; } & { [K_1 in keyof import("./schema.ts").NamespaceValues<S>]: import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<S>[K_1]; }> | undefined;
         }): import("./schema.ts").SectionSchema<F, S>;
         element<F extends import("./schema.ts").BuilderMap = {}, S extends import("./schema.ts").BuilderMap = {}>(input: {
             name: string;
@@ -124,23 +111,7 @@ export declare const smoodly: {
                 omit: string[];
             };
             css?: false;
-            sample?: Partial<{ [K_1 in Exclude<keyof F, { [K in keyof F]: F[K] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K : never : never; }[keyof F]>]: import("./fields.ts").ValueOf<F[K_1]>; } & { [K_2 in { [K in keyof F]: F[K] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K : never : never; }[keyof F]]?: import("./fields.ts").ValueOf<F[K_2]> | undefined; } & { [K_4 in Exclude<keyof S, { [K_3 in keyof S]: S[K_3] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K_3 : never : never; }[keyof S]>]: import("./fields.ts").ValueOf<S[K_4]>; } & { [K_5 in { [K_3 in keyof S]: S[K_3] extends {
-                __flags?: infer Fl;
-            } ? Fl extends {
-                optional: true;
-            } ? K_3 : never : never; }[keyof S]]?: import("./fields.ts").ValueOf<S[K_5]> | undefined; }> | undefined;
+            sample?: Partial<{ [K in keyof import("./schema.ts").NamespaceValues<F>]: import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<F>[K] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<F>[K]; } & { [K_1 in keyof import("./schema.ts").NamespaceValues<S>]: import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any> ? string : import("./schema.ts").NamespaceValues<S>[K_1] extends import("./fields.ts").RefTo<any, any>[] ? string[] : import("./schema.ts").NamespaceValues<S>[K_1]; }> | undefined;
         } & {
             contexts: ("richtext" | "column")[];
         }): import("./schema.ts").ElementSchema<F, S>;
@@ -157,8 +128,8 @@ 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, publicContentConfig } from "./env.ts";
-export type { SmoodlyEnv, ContentConfig } from "./env.ts";
+export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig } from "./env.ts";
+export type { SmoodlyEnv, PresenceConfig } from "./env.ts";
 export { clientOptions, createSmoodlyClient } from "./client.ts";
 export { createSmoodlySite, pageContextOf } from "./site.ts";
-export type { SiteOptions, SitePage, SitePageSchema, SiteEntry, SiteHit, SmoodlySite, LoadOptions, PageTreeItem, SiteEntryItem, EntryTreeItem, EntryQuery, } from "./site.ts";
+export type { SiteOptions, SitePageSchema, SmoodlySite, LoadOptions, PageTreeItem, EntryTreeItem, EntryQuery, } from "./site.ts";

package/dist/index.js

@@ -66,6 +66,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, publicContentConfig } from "./env.js";
+export { resolveSmoodlyEnv, smoodlyEnv, presenceConfig } from "./env.js";
 export { clientOptions, createSmoodlyClient } from "./client.js";
 export { createSmoodlySite, pageContextOf } from "./site.js";

package/dist/migrations.js

@@ -43,7 +43,7 @@ export function viewsFile(collections, existing, at) {
     const changed = collections.filter((c) => existing.get(c.name) !== collectionHash(c.sql));
     if (changed.length === 0)
         return null;
-    const text = "-- Smoodly: read views and order indexes for this app's collections, written by `npx smoodly migrate`\n" +
+    const text = "-- Smoodly: read views for this app's collections, written by `npx smoodly migrate`\n" +
         `-- (${at.toISOString()}). One block per collection; the marker's hash is the block's SQL, compared on the next run.\n` +
         "-- Never edit a written file: change the collection and run migrate again.\n\n" +
         changed.map((c) => `${collectionMarker(c)}\n${c.sql.trim()}`).join("\n\n") +

package/dist/next/canvas-slot.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+export declare const CanvasBridgeSlot: import("react").ComponentType<{}>;
+export declare const CanvasNetSlot: import("react").ComponentType<{
+    id: string;
+    title: string;
+    children?: ReactNode;
+}>;

package/dist/next/canvas-slot.js

@@ -0,0 +1,9 @@
+"use client";
+// The one Smoodly client module a live page carries (spec 2026-09-29
+// pre-install fixes §1). Next ships every client module a route's server
+// graph imports, rendered or not; this stub is that module, and the bridge
+// and the canvas net load from it lazily — only when the renderer is in
+// editor mode, so a live page downloads neither.
+import dynamic from "next/dynamic";
+export const CanvasBridgeSlot = dynamic(() => import("../admin/next/bridge.js").then((m) => m.EditorBridge));
+export const CanvasNetSlot = dynamic(() => import("./canvas-boundary.js").then((m) => m.CanvasBoundary));

package/dist/next/index.d.ts

@@ -1,5 +1,7 @@
 export { createPageRenderer } from "./page-renderer.tsx";
 export type { PageRendererOptions, PathRenderOptions, PageRegistration } from "./page-renderer.tsx";
-export { metadataFrom } from "./meta.ts";
+export { metadataFrom, metadataFromSeo } from "./meta.ts";
 export { createSmoodlyQueries } from "./queries.ts";
 export type { SmoodlyQueries, QueryOptions, EntriesQuery, TypedEntryItem, GlobalValue } from "./queries.ts";
+export { previewRoute } from "./preview-route.ts";
+export { previewPill } from "./preview-pill.tsx";

package/dist/next/index.js

@@ -1,3 +1,5 @@
 export { createPageRenderer } from "./page-renderer.js";
-export { metadataFrom } from "./meta.js";
+export { metadataFrom, metadataFromSeo } from "./meta.js";
 export { createSmoodlyQueries } from "./queries.js";
+export { previewRoute } from "./preview-route.js";
+export { previewPill } from "./preview-pill.js";

package/dist/next/meta.d.ts

@@ -1,8 +1,10 @@
 import type { Metadata } from "next";
-/** Maps the page tree's meta onto Next metadata (spec 2026-09-10 page
- * fields §4). The SEO title falls back to the page's own title so every
- * page carries one; absent meta and no title returns {} so the app's
- * layout.tsx defaults apply untouched. */
+import type { Seo } from "../read-shapes.ts";
+/** Maps the effective SEO values onto Next metadata (spec 2026-09-10 page
+ * fields §4, 2026-09-29 content API contract §7). Absent values leave the
+ * app's layout defaults untouched: no seo at all returns {}. */
+export declare function metadataFromSeo(seo: Seo | undefined): Metadata;
+/** A page tree's stored meta as Next metadata; the SEO title falls back to the page's own title. */
 export declare function metadataFrom(meta: unknown, page?: {
     title?: string;
 }): Metadata;

package/dist/next/meta.js

@@ -1,15 +1,10 @@
 import { imageUrl } from "../image/loaders.js";
-const isResolvedImage = (v) => typeof v === "object" && v !== null && typeof v.url === "string";
-/** Maps the page tree's meta onto Next metadata (spec 2026-09-10 page
- * fields §4). The SEO title falls back to the page's own title so every
- * page carries one; absent meta and no title returns {} so the app's
- * layout.tsx defaults apply untouched. */
-export function metadataFrom(meta, page) {
-    const m = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
-    const str = (key) => (typeof m[key] === "string" && m[key] ? m[key] : undefined);
-    const title = str("title") ?? (page?.title ? page.title : undefined);
-    const description = str("description");
-    const ogImage = m.ogImage;
+import { pageSeo } from "../seo.js";
+/** Maps the effective SEO values onto Next metadata (spec 2026-09-10 page
+ * fields §4, 2026-09-29 content API contract §7). Absent values leave the
+ * app's layout defaults untouched: no seo at all returns {}. */
+export function metadataFromSeo(seo) {
+    const { title, description, image, noindex } = seo ?? {};
     const out = {};
     if (title)
         out.title = title;
@@ -20,16 +15,18 @@ export function metadataFrom(meta, page) {
         og.title = title;
     if (description)
         og.description = description;
-    if (isResolvedImage(ogImage)) {
+    if (image) {
         // The delivery seam decides the URL; the cloud's transform loader (OQ 28) can serve a real 1200-wide render.
-        og.images = [{ url: imageUrl(ogImage, { width: 1200 }), width: ogImage.width, height: ogImage.height, ...(ogImage.alt ? { alt: ogImage.alt } : {}) }];
-    }
-    else if (typeof ogImage === "string" && ogImage) {
-        og.images = [ogImage];
+        og.images = [{ url: imageUrl(image, { width: 1200 }), width: image.width, height: image.height, ...(image.alt ? { alt: image.alt } : {}) }];
     }
     if (Object.keys(og).length > 0)
         out.openGraph = og;
-    if (m.noindex === true)
+    if (noindex === true)
         out.robots = { index: false, follow: false };
     return out;
 }
+/** A page tree's stored meta as Next metadata; the SEO title falls back to the page's own title. */
+export function metadataFrom(meta, page) {
+    const m = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
+    return metadataFromSeo(pageSeo(m, page?.title ?? ""));
+}

package/dist/next/page-renderer.d.ts

@@ -30,6 +30,8 @@ export type PageRendererOptions = {
     /** Locale-relative CMS path → site URL. Default: the path itself. With
      *  next-intl: `(path, locale) => getPathname({ locale, href: path })`. */
     href?: (path: string, locale: string) => string;
+    /** Where the preview pill's Exit goes (spec 2026-09-29 pre-install fixes §2): the route that exports `previewRoute`. Default `/api/preview`. */
+    previewRoute?: string;
 };
 export type PathRenderOptions = {
     locale?: string;

package/dist/next/page-renderer.js

@@ -1,29 +1,31 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 // The site-route seam (spec 2026-09-05 §5): the two route files call
 // renderSmoodlyPath; everything else — request gating, draft mode, the
-// cache keyed by (locale, path) and tagged by id, 404s, the editor
-// bridge — lives here, over the framework-free site layer. Bound once by
-// the app, exactly like createAdminOpHandler.
+// cache keyed by (locale, path, target) and tagged by id, 404s, the editor
+// bridge (through the lazy canvas stub) — lives here, over the
+// framework-free site layer. Bound once by the app, exactly like
+// createAdminOpHandler.
 import { Suspense } from "react";
 import { unstable_cache } from "next/cache";
 import { draftMode } from "next/headers";
 import { notFound, permanentRedirect, unstable_rethrow } from "next/navigation";
 import { connection } from "next/server";
-import { EditorBridge } from "../admin/next/bridge.js";
-import { CanvasBoundary } from "./canvas-boundary.js";
+import { CanvasBridgeSlot, CanvasNetSlot } from "./canvas-slot.js";
 import { DRAFT_META_NAME } from "../admin/editor/canvas-diagnosis.js";
 import { fixedPathFor } from "../localize.js";
 import { decodeSegment, joinPath } from "../paths.js";
 import { renderPage } from "../render.js";
 import { entryTag, pageTag, globalTag } from "../revalidate.js";
+import { toEntryItem } from "../read-shapes.js";
 import { pageContextOf } from "../site.js";
-import { metadataFrom } from "./meta.js";
+import { metadataFromSeo } from "./meta.js";
+import { previewPill } from "./preview-pill.js";
 /** Logged once per renderer when Next's cacheComponents is on (spec 2026-09-27 cache components §2). */
 export const CACHE_COMPONENTS_WARNING = "smoodly: Next's cacheComponents is on, and Smoodly does not support it — a missing page answers 200 with noindex instead of 404, and a redirect answers 200 instead of 308. Turn cacheComponents off in next.config.ts; the Next.js guide's \"Cache Components\" section says why (https://smoodly.io/docs/frameworks/nextjs).";
 /** The canvas net (spec 2026-09-27 section guard §5): Server Components hand a section that failed to the
  *  browser, where CanvasBoundary catches it. Defined here, not in the client file: a function exported
  *  from a "use client" module is a reference on the server and cannot be called. */
-const canvasWrap = (child, section) => (_jsx(Suspense, { fallback: null, children: _jsx(CanvasBoundary, { id: section.id, title: section.title, children: child }) }));
+const canvasWrap = (child, section) => (_jsx(Suspense, { fallback: null, children: _jsx(CanvasNetSlot, { id: section.id, title: section.title, children: child }) }));
 export function createPageRenderer(options) {
     const { site } = options;
     const href = options.href ?? ((path) => path);
@@ -34,7 +36,10 @@ export function createPageRenderer(options) {
     async function load(target, locale, path, draft, version) {
         if (draft)
             return site.load(target, locale, path, { draft: true, ...(version !== undefined ? { version } : {}) });
-        return unstable_cache(() => site.load(target, locale, path), ["smoodly-site", locale, path], {
+        // Keyed by what the unit holds, not only where: an address that changes
+        // owner — a deploy handing it to a code record, which fires no tag —
+        // can never serve the previous occupant (spec 2026-09-29 pre-install fixes §5).
+        return unstable_cache(() => site.load(target, locale, path), ["smoodly-site", locale, path, target.kind, target.id], {
             tags: [target.kind === "page" ? pageTag(target.id) : entryTag(target.id)],
         })();
     }
@@ -69,7 +74,7 @@ export function createPageRenderer(options) {
             console.warn(`smoodly: no entry page for collection "${hit.collection}" — the entry at ${hit.path} is a 404.`);
             notFound();
         }
-        return _jsx(View, { entry: hit.entry, path: hit.path, locale: hit.locale, locales: hit.locales });
+        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) {
@@ -115,7 +120,7 @@ export function createPageRenderer(options) {
         // The draft marker tells the page editor's canvas diagnosis that Smoodly
         // rendered this response (spec 2026-09-27 shadowed-page detector §3);
         // React hoists the meta into the head. Never outside draft mode.
-        return (_jsxs(_Fragment, { children: [draft ? _jsx("meta", { name: DRAFT_META_NAME }) : null, editor ? _jsx(EditorBridge, {}) : null, render(hit, editor, locale)] }));
+        return (_jsxs(_Fragment, { children: [draft ? _jsx("meta", { name: DRAFT_META_NAME }) : null, editor ? _jsx(CanvasBridgeSlot, {}) : null, draft && !editor && !version ? previewPill({ route: options.previewRoute }) : null, render(hit, editor, locale)] }));
     }
     async function metadata(pathFor, opts, accept) {
         // generateMetadata runs alongside the page render, so it gates too.
@@ -129,7 +134,9 @@ export function createPageRenderer(options) {
         const hit = await load(target, locale, path, draft);
         if (!hit || !accept(hit))
             return {};
-        return { ...(hit.kind === "page" ? metadataFrom(hit.tree.meta, { title: hit.title }) : {}), ...alternates(hit) };
+        // 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 any = () => true;
     /** The escape hatch may only render ITS OWN registration's record. */

package/dist/next/preview-pill.d.ts

@@ -0,0 +1,9 @@
+import { type ReactElement } from "react";
+/** The pill's whole client side. `closed` lives in the closure, so a hidden
+ *  pill stays hidden across client navigations and returns on a reload. */
+export declare const PREVIEW_PILL_SCRIPT: string;
+/** The pill for a route that does not go through the renderer: render it
+ *  when `(await draftMode()).isEnabled`, never in the editor's canvas. */
+export declare function previewPill(opts?: {
+    route?: string;
+}): ReactElement;