@seamlet/astro 0.8.0 → 0.9.0

package/README.md

@@ -46,21 +46,28 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    <h1 {...edit("title")}>{content.title}</h1>
    ```
 
-3. Name the site's address in the CMS and its pages: components that take the content as their `content` prop.
+3. Describe the site for the CMS: its address and name there, its schema, the content it starts with, and its pages, each with the name the editor gives it and the component that renders it (it takes the content as its `content` prop). The home page `/` comes first; `searchTexts` names where the content holds a page's title and description for search engines, a group of a `title` and a `description` text (`seoFields`).
 
    ```ts
    // src/seamlet.ts
    import { defineSeamletSite } from "@seamlet/astro/site";
    import HomePage from "./components/HomePage.astro";
+   import { initialContent } from "./initial-content";
    import { schema } from "./schema";
 
    export default defineSeamletSite({
      id: "zerno",
+     title: "Кофейня «Зерно»",
      schema,
-     pages: { "/": HomePage },
+     initialContent,
+     pages: {
+       "/": { title: "Главная", component: HomePage, searchTexts: "seo.home" },
+     },
    });
    ```
 
+   The CMS takes all of it from the site itself, so connecting a site, or changing its schema, needs no change of the CMS.
+
 4. Add the integration:
 
    ```js
@@ -74,7 +81,7 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    });
    ```
 
-The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise.
+The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise. A module that needs the content without importing every page takes it with `loadPublishedContent(id, schema)` of `@seamlet/astro/site`.
 
 ## Fields
 
@@ -136,8 +143,10 @@ const MENU_FILES = import.meta.glob<{ default: ImageMetadata }>(
 
 export default defineSeamletSite({
   id: "zerno",
+  title: "Кофейня «Зерно»",
   schema,
-  pages: { "/": HomePage },
+  initialContent,
+  pages: { "/": { title: "Главная", component: HomePage } },
   photos: (src) => MENU_FILES[src.replace("/menu/", "./assets/menu/")]?.default,
 });
 ```
@@ -219,9 +228,10 @@ What was opened stays open while the page is rendered anew after every edit.
 
 - `/preview` and `/preview/<page>`: the preview the CMS's editor frames. `GET` shows the published content; `POST` with the content as JSON shows that content without saving it, which is how the editor shows every edit at once. Only the CMS may frame it (`Content-Security-Policy: frame-ancestors`), and it is never indexed or cached.
 - The bridge on the preview: it tells the editor where the marked elements are and what a person does on the page, and types texts in place, formatted ones too.
+- `/seamlet/site.json`: what the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`): its name, its schema, the content it starts with and its pages. The CMS reads it with `readSiteDescription` whenever the site is opened in its editor.
 - `/seamlet-photos/<address>`: the site's own photo at an address its content gives it, found by `photos` of `defineSeamletSite`, for the CMS's editor.
 - `/media/<site>/<file>`: the photos uploaded in the CMS, taken from it on request; a static build copies every uploaded photo its built pages refer to next to them, so a static host serves them too.
 
 A site never renders content as raw HTML (`set:html`): the editor acts on what its preview says.
 
-The preview's address goes on the site's settings page in the CMS: `https://<site>/preview`.
+To connect the site, an administrator of the CMS gives it the preview's address, `https://<site>/preview`; the CMS takes the site's description from its origin.

package/dist/bridge.js

@@ -18,15 +18,42 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-27XIZEVS.js";
+} from "./chunk-UBBVOSON.js";
 import {
   FIELD_PATH_ATTRIBUTE,
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
   asOneParagraph,
-  readRichText
-} from "./chunk-ZUJEM3P7.js";
+  readRichText,
+  resolveFieldPath
+} from "./chunk-NFUGV7JJ.js";
+
+// src/bridge/typed-fields.ts
+function typedKindAt(schema, path) {
+  const target = resolveFieldPath(schema, path);
+  if (target?.kind !== "field") return void 0;
+  switch (target.field.kind) {
+    case "text":
+      return "plain";
+    case "richText":
+      return "rich";
+    case "number":
+    case "date":
+    case "time":
+    case "image":
+    case "link":
+    case "url":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "reference":
+    case "references":
+    case "group":
+    case "collection":
+      return void 0;
+  }
+}
 
 // src/bridge/page-markers.ts
 var MARKER_SELECTOR = `[${FIELD_PATH_ATTRIBUTE}]`;
@@ -524,7 +551,7 @@ function caretRangeAt(document2, point) {
 }
 
 // src/bridge/rich-text-editing.ts
-var EDITABLE = "true";
+var EDITABLE_AS_RICH_TEXT = "true";
 var PASTED_LINE_BREAKS = /\s*\n\s*/gu;
 var SPACE = " ";
 function canEditRichTextInPlace(element, value, isInline) {
@@ -636,7 +663,7 @@ function startRichTextEditing(element, options) {
     options.onSelect(void 0);
     options.onEnd(outcome);
   };
-  element.setAttribute("contenteditable", EDITABLE);
+  element.setAttribute("contenteditable", EDITABLE_AS_RICH_TEXT);
   element.addEventListener("input", reportInput);
   element.addEventListener("keydown", pressKey);
   element.addEventListener("paste", pastePlainText);
@@ -708,9 +735,35 @@ function formatShortcutOf(event) {
 }
 
 // src/bridge/page-typing.ts
+var PREPARED_TYPING_TIMEOUT_MS = 3e3;
+var EDITABLE_VALUES = {
+  plain: EDITABLE_AS_PLAIN_TEXT,
+  rich: EDITABLE_AS_RICH_TEXT
+};
 function createPageTyping(options) {
   let stopEditing;
   let richEditing;
+  let prepared;
+  const takePrepared = (isTyped) => {
+    if (prepared === void 0) return;
+    clearTimeout(prepared.timer);
+    if (!isTyped && stopEditing === void 0) {
+      prepared.element.blur();
+      prepared.element.removeAttribute("contenteditable");
+    }
+    prepared = void 0;
+  };
+  const prepare = (element, kind) => {
+    const isTypedAlready = element.hasAttribute("contenteditable");
+    if (isTypedAlready) return;
+    takePrepared(false);
+    element.setAttribute("contenteditable", EDITABLE_VALUES[kind]);
+    element.focus({ preventScroll: true });
+    const timer = setTimeout(() => {
+      takePrepared(false);
+    }, PREPARED_TYPING_TIMEOUT_MS);
+    prepared = { element, timer };
+  };
   const stop = () => {
     stopEditing?.();
   };
@@ -725,9 +778,11 @@ function createPageTyping(options) {
     const element = findMarkedElement(options.document, path);
     const canType = element !== void 0 && canEditTextInPlace(element, request.text);
     if (!canType) {
+      takePrepared(false);
       options.send({ type: "typing-refused", path });
       return;
     }
+    takePrepared(true);
     options.send({ type: "typing-started", path });
     stopEditing = startInlineTextEditing(element, {
       isSingleLine: request.isSingleLine,
@@ -745,9 +800,11 @@ function createPageTyping(options) {
     const element = findMarkedElement(options.document, path);
     const canType = element !== void 0 && canEditRichTextInPlace(element, request.text, isInline);
     if (!canType) {
+      takePrepared(false);
       options.send({ type: "typing-refused", path });
       return;
     }
+    takePrepared(true);
     options.send({ type: "typing-started", path });
     const editing = startRichTextEditing(element, {
       isInline,
@@ -765,6 +822,7 @@ function createPageTyping(options) {
     placeCaretAt(element, request.point);
   };
   return {
+    prepare,
     isTyping: () => stopEditing !== void 0,
     start,
     startRich,
@@ -832,6 +890,10 @@ function connectPage(document2, schema, send) {
       send({ type: "hover", path });
     },
     onClick: (pointer) => {
+      const kind = pointer === void 0 ? void 0 : typedKindAt(schema, pointer.path);
+      if (pointer !== void 0 && kind !== void 0) {
+        typing.prepare(pointer.element, kind);
+      }
       const target = pointer === void 0 ? void 0 : { path: pointer.path, point: pointer.point };
       send({ type: "click", target });
     },

package/dist/{chunk-ZUJEM3P7.js → chunk-NFUGV7JJ.js}

@@ -786,6 +786,185 @@ function openingHoursField(options = {}) {
   });
 }
 
+// src/schema/read-fields.ts
+function readFields(input) {
+  if (!isRecord2(input)) return void 0;
+  const entries = Object.entries(input).map(
+    ([name, value]) => [name, readField(value)]
+  );
+  const readEntries = entries.flatMap(
+    ([name, field]) => field === void 0 ? [] : [[name, field]]
+  );
+  const isEveryFieldRead = readEntries.length === entries.length;
+  return isEveryFieldRead ? Object.fromEntries(readEntries) : void 0;
+}
+function readField(input) {
+  if (!isRecord2(input)) return void 0;
+  const label = input["label"];
+  if (typeof label !== "string") return void 0;
+  const kind = input["kind"];
+  return isFieldKind(kind) ? readFieldOfKind(kind, label, input) : void 0;
+}
+function readFieldOfKind(kind, label, input) {
+  switch (kind) {
+    case "text":
+      return {
+        kind,
+        label,
+        ...optional("multiline", input["multiline"], isBoolean),
+        ...optional("maxLength", input["maxLength"], isCount)
+      };
+    case "richText":
+      return {
+        kind,
+        label,
+        ...optional("inline", input["inline"], isBoolean),
+        ...optional("maxLength", input["maxLength"], isCount)
+      };
+    case "number":
+      return {
+        kind,
+        label,
+        ...optional("min", input["min"], isNumber),
+        ...optional("max", input["max"], isNumber)
+      };
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "url":
+    case "time":
+      return { kind, label };
+    case "choice":
+    case "choices":
+      return readChoiceField(kind, label, input["options"]);
+    case "reference":
+    case "references":
+      return readReferenceField(kind, label, input["collection"]);
+    case "group":
+      return readGroupField(label, input["fields"]);
+    case "collection":
+      return readCollectionField(label, input);
+  }
+}
+function readChoiceField(kind, label, input) {
+  if (!Array.isArray(input)) return void 0;
+  const options = input;
+  if (!options.every(isChoiceOption)) return void 0;
+  const read = options.map(({ value, label: optionLabel }) => ({
+    value,
+    label: optionLabel
+  }));
+  return { kind, label, options: read };
+}
+function readReferenceField(kind, label, collection2) {
+  return typeof collection2 === "string" ? { kind, label, collection: collection2 } : void 0;
+}
+function readGroupField(label, input) {
+  const fields = readFields(input);
+  return fields === void 0 ? void 0 : { kind: "group", label, fields };
+}
+function readCollectionField(label, input) {
+  const item = readFields(input["item"]);
+  if (item === void 0 || "id" in item) return void 0;
+  const itemTitle = input["itemTitle"];
+  const isTitleKnown = typeof itemTitle === "string" && itemTitle in item;
+  if (itemTitle !== void 0 && !isTitleKnown) return void 0;
+  return {
+    kind: "collection",
+    label,
+    item,
+    ...isTitleKnown ? { itemTitle } : {}
+  };
+}
+function optional(key, value, isOfKind) {
+  if (!isOfKind(value)) return {};
+  return { [key]: value };
+}
+var FIELD_KINDS = /* @__PURE__ */ new Set([
+  "text",
+  "richText",
+  "number",
+  "date",
+  "image",
+  "link",
+  "toggle",
+  "choice",
+  "choices",
+  "url",
+  "time",
+  "reference",
+  "references",
+  "group",
+  "collection"
+]);
+function isFieldKind(value) {
+  return typeof value === "string" && FIELD_KINDS.has(value);
+}
+function isChoiceOption(value) {
+  return isRecord2(value) && typeof value["value"] === "string" && typeof value["label"] === "string";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isCount(value) {
+  return isNumber(value) && Number.isInteger(value) && value >= 0;
+}
+
+// src/schema/site-description.ts
+var SITE_DESCRIPTION_PATH = "/seamlet/site.json";
+var SITE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
+var PAGE_PATH = /^(\/[a-z0-9][a-z0-9-]*)+$/u;
+var HOME_PAGE_PATH = "/";
+function readSiteDescription(input) {
+  if (!isRecord3(input)) return void 0;
+  const { id, title } = input;
+  const schema = readFields(input["schema"]);
+  const isNamed = typeof id === "string" && SITE_ID.test(id) && isText(title);
+  if (!isNamed || schema === void 0) return void 0;
+  const initial = parseContent(schema, input["initialContent"]);
+  const pages = readPages(schema, input["pages"]);
+  if (initial.issues.length > 0 || pages === void 0) return void 0;
+  return { id, title, schema, initialContent: initial.content, pages };
+}
+function isSearchTextsGroup(schema, path) {
+  const target = resolveFieldPath(schema, path);
+  if (target?.kind !== "field" || target.field.kind !== "group") return false;
+  const { title, description } = target.field.fields;
+  return title?.kind === "text" && description?.kind === "text";
+}
+function readPages(schema, input) {
+  if (!Array.isArray(input)) return void 0;
+  const entries = input;
+  const pages = entries.map((entry) => readPage(schema, entry));
+  const read = pages.flatMap((page) => page === void 0 ? [] : [page]);
+  const [first, ...rest] = read;
+  const paths = new Set(read.map((page) => page.path));
+  const isSound = read.length === pages.length && first?.path === HOME_PAGE_PATH && paths.size === read.length;
+  return isSound ? [first, ...rest] : void 0;
+}
+function readPage(schema, input) {
+  if (!isRecord3(input)) return void 0;
+  const { path, title, searchTexts } = input;
+  const isPath = typeof path === "string" && (path === HOME_PAGE_PATH || PAGE_PATH.test(path));
+  if (!isPath || !isText(title)) return void 0;
+  if (searchTexts === void 0) return { path, title };
+  const isSearchTexts = typeof searchTexts === "string" && isSearchTextsGroup(schema, searchTexts);
+  return isSearchTexts ? { path, title, searchTexts } : void 0;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+
 export {
   defineSchema,
   text,
@@ -831,5 +1010,9 @@ export {
   seoFields,
   contactsFields,
   WEEKDAYS,
-  openingHoursField
+  openingHoursField,
+  readFields,
+  SITE_DESCRIPTION_PATH,
+  readSiteDescription,
+  isSearchTextsGroup
 };

package/dist/{chunk-27XIZEVS.js → chunk-UBBVOSON.js}

@@ -3,7 +3,7 @@ import {
   normalizedLine,
   readRichText,
   resolveFieldPath
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-NFUGV7JJ.js";
 
 // src/bridge/editor-shortcuts.ts
 function shortcutOf(event) {

package/dist/index.js

@@ -1,6 +1,9 @@
 import {
   OWN_PHOTOS_PATH
 } from "./chunk-3BS5CE26.js";
+import {
+  SITE_DESCRIPTION_PATH
+} from "./chunk-NFUGV7JJ.js";
 import {
   isUploadedPhoto
 } from "./chunk-P2OQOZBC.js";
@@ -92,6 +95,11 @@ function seamlet(options) {
           entrypoint: "@seamlet/astro/routes/media",
           prerender: false
         });
+        injectRoute({
+          pattern: SITE_DESCRIPTION_PATH,
+          entrypoint: "@seamlet/astro/routes/site-description",
+          prerender: false
+        });
         injectRoute({
           pattern: `${OWN_PHOTOS_PATH}/[...path]`,
           entrypoint: "@seamlet/astro/routes/own-photos",

package/dist/protocol.js

@@ -22,8 +22,8 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-27XIZEVS.js";
-import "./chunk-ZUJEM3P7.js";
+} from "./chunk-UBBVOSON.js";
+import "./chunk-NFUGV7JJ.js";
 export {
   OWN_PHOTOS_PATH,
   PROTOCOL_VERSION,

package/dist/routes/site-description.d.ts

@@ -0,0 +1,5 @@
+import { APIRoute } from 'astro';
+
+declare const GET: APIRoute;
+
+export { GET };

package/dist/routes/site-description.js

@@ -0,0 +1,8 @@
+// src/routes/site-description.ts
+import site from "virtual:seamlet/site";
+var GET = () => Response.json(site.description, {
+  headers: { "Cache-Control": "no-store", "X-Robots-Tag": "noindex" }
+});
+export {
+  GET
+};

package/dist/schema.d.ts

@@ -2,6 +2,7 @@ import { b as ImageValue, L as LinkValue, c as Field, d as CollectionField, F as
 export { i as ChoiceField, j as ChoiceOption, D as DateField, k as FieldKind, l as FieldValue, m as ImageFocus, N as NumberField, O as OptionValue, n as RecordOf, o as ReferenceField, p as ReferencesField, q as RichBlock, r as RichLine, s as RichSpan, R as RichText, t as RichTextField, u as ToggleField, V as ValueOf, v as asOneParagraph, w as choice, x as choices, y as collection, z as date, A as defaultContent, B as defaultValue, E as defineSchema, H as group, J as image, K as link, M as normalizedLine, P as number, Q as plainTextOf, S as readRichText, W as reference, X as references, Y as richText, Z as richTextOf, _ as text, $ as time, a0 as toggle, a1 as url } from './content-6k-E7NWf.js';
 import { F as FieldPath } from './parse-content-C9ldnmvj.js';
 export { C as ContentIssue, P as ParsedContent, c as countCharacters, f as formatFieldPath, p as parseContent } from './parse-content-C9ldnmvj.js';
+export { a as SITE_DESCRIPTION_PATH, S as SiteDescription, b as SitePageDescription, i as isSearchTextsGroup, r as readSiteDescription } from './site-description-4Jx6Nq6X.js';
 
 declare const FIELD_PATH_ATTRIBUTE = "data-cms-path";
 interface FieldMarker {
@@ -171,4 +172,7 @@ declare function openingHoursField(options?: {
     note: TextField;
 }>;
 
-export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, linkTargetOf, newRecord, openingHoursField, resolveFieldPath, seoFields, withRecordIds };
+/** The schema the input describes, or undefined when it is not one. */
+declare function readFields(input: unknown): Fields | undefined;
+
+export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, linkTargetOf, newRecord, openingHoursField, readFields, resolveFieldPath, seoFields, withRecordIds };

package/dist/schema.js

@@ -4,6 +4,7 @@ import {
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
   choice,
@@ -24,6 +25,7 @@ import {
   image,
   imagePosition,
   isRecordId,
+  isSearchTextsGroup,
   link,
   linkTargetOf,
   newRecord,
@@ -32,7 +34,9 @@ import {
   openingHoursField,
   parseContent,
   plainTextOf,
+  readFields,
   readRichText,
+  readSiteDescription,
   reference,
   references,
   resolveFieldPath,
@@ -44,13 +48,14 @@ import {
   toggle,
   url,
   withRecordIds
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-NFUGV7JJ.js";
 export {
   FIELD_PATH_ATTRIBUTE,
   RECORD_ID_KEY,
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
   choice,
@@ -71,6 +76,7 @@ export {
   image,
   imagePosition,
   isRecordId,
+  isSearchTextsGroup,
   link,
   linkTargetOf,
   newRecord,
@@ -79,7 +85,9 @@ export {
   openingHoursField,
   parseContent,
   plainTextOf,
+  readFields,
   readRichText,
+  readSiteDescription,
   reference,
   references,
   resolveFieldPath,

package/dist/site-description-4Jx6Nq6X.d.ts

@@ -0,0 +1,36 @@
+import { F as Fields, a as Content } from './content-6k-E7NWf.js';
+
+/** Where a site hands out its description, on the origin of its preview. */
+declare const SITE_DESCRIPTION_PATH = "/seamlet/site.json";
+/** A page of a site, which the site renders itself. */
+interface SitePageDescription {
+    /** The address of the page on the site: `/` for the first page, `/menu` for others. */
+    readonly path: string;
+    /** How the editor names the page in its list of pages. */
+    readonly title: string;
+    /**
+     * Where the content holds what search engines and link previews show for the page
+     * (`seo.menu`): a group of a `title` and a `description` text.
+     */
+    readonly searchTexts?: string;
+}
+interface SiteDescription {
+    /** The address of the site in the CMS (`/sites/<id>`). */
+    readonly id: string;
+    /** How the CMS names the site. */
+    readonly title: string;
+    readonly schema: Fields;
+    /** The content shown and edited until the first save. */
+    readonly initialContent: Content;
+    /** The pages of the site; the first is the home page at `/`. */
+    readonly pages: readonly [SitePageDescription, ...SitePageDescription[]];
+}
+/**
+ * The description the input gives, or undefined when it is not a whole and sound one: a known
+ * schema, an initial content with nothing to fix, the home page first, each page once.
+ */
+declare function readSiteDescription(input: unknown): SiteDescription | undefined;
+/** Whether the path names a group of a `title` and a `description` text. */
+declare function isSearchTextsGroup(schema: Fields, path: string): boolean;
+
+export { type SiteDescription as S, SITE_DESCRIPTION_PATH as a, type SitePageDescription as b, isSearchTextsGroup as i, readSiteDescription as r };

package/dist/site.d.ts

@@ -1,16 +1,26 @@
 import { ImageMetadata } from 'astro';
 import { AstroComponentFactory } from 'astro/runtime/server/index.js';
 import { F as Fields, C as ContentOf } from './content-6k-E7NWf.js';
+import { S as SiteDescription } from './site-description-4Jx6Nq6X.js';
 
+/** A page of the site: how the editor names it, and the component that renders it. */
+interface SeamletPage {
+    readonly title: string;
+    /** A component that takes the site's content as its `content` prop. */
+    readonly component: AstroComponentFactory;
+    /** Where the content holds the page's title and description for search engines (`seo.menu`). */
+    readonly searchTexts?: string;
+}
 interface SeamletSiteDefinition<F extends Fields> {
     /** The site's address in the CMS: `/sites/<id>`. */
     readonly id: string;
+    /** How the CMS names the site: «Кофейня «Зерно»». */
+    readonly title: string;
     readonly schema: F;
-    /**
-     * The pages of the site by their address (`/`, `/menu`): components that take the site's content
-     * as their `content` prop. The CMS lists the same addresses for its editor.
-     */
-    readonly pages: Readonly<Record<string, AstroComponentFactory>>;
+    /** The content the site shows, and the CMS edits, until the first publication. */
+    readonly initialContent: ContentOf<F>;
+    /** The pages of the site by their address (`/`, `/menu`); the home page `/` comes first. */
+    readonly pages: Readonly<Record<string, SeamletPage>>;
     /**
      * The site's own photo at the address its content gives it (`/menu/cafe/01.jpg`), so the CMS's
      * editor can show it in the photo's field. A site without own photos leaves it out.
@@ -26,8 +36,15 @@ interface SeamletSite<F extends Fields = Fields> {
     readonly loadPublishedContent: () => Promise<ContentOf<F>>;
     /** The site's own photo at an address its content gives it, if it has one there. */
     readonly ownPhotoAt: (src: string) => ImageMetadata | undefined;
+    /** What the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`). */
+    readonly description: SiteDescription;
 }
 /** Describes the site for the integration: `src/seamlet.ts` exports it as its default. */
 declare function defineSeamletSite<F extends Fields>(definition: SeamletSiteDefinition<F>): SeamletSite<F>;
+/**
+ * What the CMS published for the site with this id, in the shape of its schema: the site's initial
+ * content until the first publication. For a module that needs the content without the pages.
+ */
+declare function loadPublishedContent<F extends Fields>(siteId: string, schema: F): Promise<ContentOf<F>>;
 
-export { type SeamletSite, type SeamletSiteDefinition, defineSeamletSite };
+export { type SeamletPage, type SeamletSite, type SeamletSiteDefinition, defineSeamletSite, loadPublishedContent };

package/dist/site.js

@@ -1,23 +1,49 @@
 import {
   parseContent
-} from "./chunk-ZUJEM3P7.js";
+} from "./chunk-NFUGV7JJ.js";
 
 // src/site.ts
 import { cmsOrigin } from "virtual:seamlet/config";
+
+// src/site-descriptions.ts
+function describeSite(definition) {
+  const pages = Object.entries(definition.pages).map(
+    ([path, page]) => ({
+      path,
+      title: page.title,
+      ...page.searchTexts === void 0 ? {} : { searchTexts: page.searchTexts }
+    })
+  );
+  const [home, ...rest] = pages;
+  if (home === void 0) {
+    throw new Error(`The site "${definition.id}" has no pages`);
+  }
+  return {
+    id: definition.id,
+    title: definition.title,
+    schema: definition.schema,
+    initialContent: definition.initialContent,
+    pages: [home, ...rest]
+  };
+}
+
+// src/site.ts
 var HOME_PAGE_PATH = "/";
 function defineSeamletSite(definition) {
   const pages = new Map(Object.entries(definition.pages));
   return {
     id: definition.id,
     schema: definition.schema,
-    pageAt: (rest) => pages.get(rest === void 0 ? HOME_PAGE_PATH : `/${rest}`),
-    loadPublishedContent: async () => {
-      const published = await fetchPublished(definition.id);
-      return parseContent(definition.schema, published).content;
-    },
-    ownPhotoAt: (src) => definition.photos?.(src)
+    pageAt: (rest) => pages.get(rest === void 0 ? HOME_PAGE_PATH : `/${rest}`)?.component,
+    loadPublishedContent: () => loadPublishedContent(definition.id, definition.schema),
+    ownPhotoAt: (src) => definition.photos?.(src),
+    description: describeSite(definition)
   };
 }
+async function loadPublishedContent(siteId, schema) {
+  const published = await fetchPublished(siteId);
+  return parseContent(schema, published).content;
+}
 async function fetchPublished(siteId) {
   const url = new URL(`/api/sites/${siteId}/published`, cmsOrigin);
   const response = await fetch(url);
@@ -29,5 +55,6 @@ async function fetchPublished(siteId) {
   return response.json();
 }
 export {
-  defineSeamletSite
+  defineSeamletSite,
+  loadPublishedContent
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamlet/astro",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Connects an Astro site to the Seamlet CMS: the schema of its content, the preview the editor frames, and its published content.",
   "license": "MIT",
   "type": "module",
@@ -47,6 +47,10 @@
       "types": "./dist/routes/own-photos.d.ts",
       "default": "./dist/routes/own-photos.js"
     },
+    "./routes/site-description": {
+      "types": "./dist/routes/site-description.d.ts",
+      "default": "./dist/routes/site-description.js"
+    },
     "./components/RichText.astro": "./components/RichText.astro"
   },
   "files": [