@seamlet/astro 0.11.2 → 0.12.0

package/dist/{chunk-DRDPKFHZ.js → chunk-7GYJS7ZT.js}

@@ -80,6 +80,73 @@ function defaultContent(fields) {
   );
 }
 
+// src/schema/field-paths.ts
+var RECORD_INDEX_PATTERN = /^\d+$/u;
+var FIELD_PATH_SEPARATOR = ".";
+function isRecordIndex(segment) {
+  return RECORD_INDEX_PATTERN.test(segment);
+}
+function resolveFieldPath(schema, text2) {
+  return resolveInFields(schema, text2.split(FIELD_PATH_SEPARATOR), []);
+}
+function resolveInFields(fields, segments, parentPath) {
+  const [name, ...rest] = segments;
+  const field = name !== void 0 && Object.hasOwn(fields, name) ? fields[name] : void 0;
+  if (name === void 0 || field === void 0) {
+    return void 0;
+  }
+  const path = [...parentPath, name];
+  if (rest.length === 0) {
+    return { kind: "field", path, field };
+  }
+  return resolveInsideField(field, rest, path);
+}
+function resolveInsideField(field, segments, path) {
+  switch (field.kind) {
+    case "group":
+      return resolveInFields(field.fields, segments, path);
+    case "collection":
+      return resolveInCollection(field, segments, path);
+    case "text":
+    case "richText":
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "url":
+    case "time":
+    case "reference":
+    case "references":
+      return void 0;
+  }
+}
+function resolveInCollection(collection2, segments, collectionPath) {
+  const [indexText, ...rest] = segments;
+  if (indexText === void 0 || !isRecordIndex(indexText)) {
+    return void 0;
+  }
+  const index = Number(indexText);
+  const recordPath = [...collectionPath, index];
+  if (rest.length === 0) {
+    return { kind: "record", path: recordPath, collection: collection2, index };
+  }
+  return resolveInFields(collection2.item, rest, recordPath);
+}
+
+// src/schema/json-values.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContentObject(value) {
+  return isJsonObject(value);
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+
 // src/schema/link-addresses.ts
 var PHONE_PREFIX = "tel:";
 var EMAIL_PREFIX = "mailto:";
@@ -87,7 +154,7 @@ var WEB_PREFIX = "https://";
 var SITE_ORIGIN = "https://site.invalid";
 var FIRST_PRINTABLE_CODE = 32;
 var DELETE_CODE = 127;
-var BACKSLASH_CODE = 92;
+var BACKSLASH = "\\";
 var WEB_ADDRESS = /^https?:\/\/[^\s/?#]+[^\s]*$/iu;
 var ANY_SCHEME = /^[a-z][a-z\d+.-]*:(?!\d)/iu;
 var PHONE_NUMBER = /^\+?[\d\s().-]*\d[\d\s().-]*$/u;
@@ -96,7 +163,7 @@ var EMAIL_ADDRESS = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
 function linkTargetOf(href) {
   const address = href;
   const hasSpacesAround = address !== address.trim();
-  if (hasSpacesAround) {
+  if (hasSpacesAround || hasControlCharacter(address)) {
     return void 0;
   }
   if (isSitePath(address)) {
@@ -115,6 +182,9 @@ function linkTargetOf(href) {
   }
   return void 0;
 }
+function safeHref(href) {
+  return linkTargetOf(href) === void 0 ? void 0 : href;
+}
 function hrefOf(target) {
   switch (target.kind) {
     case "page":
@@ -132,18 +202,18 @@ function webAddressOf(typed) {
   return hasScheme || typed === "" ? typed : `${WEB_PREFIX}${typed}`;
 }
 function isSitePath(address) {
-  if (!address.startsWith("/") || hasAmbiguousCharacter(address)) {
+  if (!address.startsWith("/") || address.includes(BACKSLASH)) {
     return false;
   }
   return new URL(address, SITE_ORIGIN).origin === SITE_ORIGIN;
 }
-function hasAmbiguousCharacter(address) {
+function hasControlCharacter(address) {
   const codes = Array.from(
     { length: address.length },
     (_, index) => address.charCodeAt(index)
   );
   return codes.some(
-    (code) => code === BACKSLASH_CODE || code < FIRST_PRINTABLE_CODE || code === DELETE_CODE
+    (code) => code < FIRST_PRINTABLE_CODE || code === DELETE_CODE
   );
 }
 function withoutPrefix(address, prefix) {
@@ -195,7 +265,7 @@ function normalizedLine(spans) {
   }, []);
 }
 function readBlock(input) {
-  if (!isObject(input)) return void 0;
+  if (!isJsonObject(input)) return void 0;
   if (input["kind"] === "paragraph") {
     const spans = readLine(input["spans"]);
     return spans === void 0 ? void 0 : { kind: "paragraph", spans };
@@ -215,7 +285,7 @@ function readLine(input) {
   return isEverySpanRead ? normalizedLine(spans) : void 0;
 }
 function readSpan(input) {
-  if (!isObject(input)) return void 0;
+  if (!isJsonObject(input)) return void 0;
   const { text: text2, bold, italic, href } = input;
   const hasValidMarks = typeof text2 === "string" && (bold === void 0 || bold === true) && (italic === void 0 || italic === true) && (href === void 0 || typeof href === "string");
   if (!hasValidMarks) return void 0;
@@ -243,9 +313,6 @@ function plainBlockOf(block) {
 function plainLineOf(line) {
   return line.map((span) => span.text).join("");
 }
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/schema/record-ids.ts
 var RECORD_ID_KEY = "id";
@@ -259,23 +326,63 @@ function newRecord(collection2, id) {
 function withRecordIds(schema, content, newId) {
   return withIdsInFields(schema, content, newId);
 }
-var COLLECTION_PATH_SEPARATOR = ".";
 function collectionAt(schema, content, path) {
-  return collectionIn(schema, content, path.split(COLLECTION_PATH_SEPARATOR));
+  return collectionIn(schema, content, path.split(FIELD_PATH_SEPARATOR));
 }
 function collectionIn(fields, content, names) {
   const [name, ...rest] = names;
   const field = name !== void 0 && Object.hasOwn(fields, name) ? fields[name] : void 0;
   if (name === void 0 || field === void 0) return void 0;
   const value = content[name];
-  if (rest.length === 0 && field.kind === "collection") {
-    const records = Array.isArray(value) ? value.filter(isContent) : [];
-    return { collection: field, records };
+  const isLast = rest.length === 0;
+  switch (field.kind) {
+    case "collection": {
+      const records = Array.isArray(value) ? value.filter(isContentObject) : [];
+      return isLast ? { collection: field, records } : void 0;
+    }
+    case "group":
+      return !isLast && isContentObject(value) ? collectionIn(field.fields, value, rest) : void 0;
+    case "text":
+    case "richText":
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "url":
+    case "time":
+    case "reference":
+    case "references":
+      return void 0;
   }
-  if (rest.length > 0 && field.kind === "group" && isContent(value)) {
-    return collectionIn(field.fields, value, rest);
+}
+function collectionFieldAt(schema, path) {
+  const [name, ...rest] = path.split(FIELD_PATH_SEPARATOR);
+  const field = name !== void 0 && Object.hasOwn(schema, name) ? schema[name] : void 0;
+  if (field === void 0) return void 0;
+  const isLast = rest.length === 0;
+  switch (field.kind) {
+    case "collection":
+      return isLast ? field : void 0;
+    case "group":
+      return isLast ? void 0 : collectionFieldAt(field.fields, rest.join(FIELD_PATH_SEPARATOR));
+    case "text":
+    case "richText":
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "url":
+    case "time":
+    case "reference":
+    case "references":
+      return void 0;
   }
-  return void 0;
 }
 function findRecord(records, id) {
   if (id === null) return void 0;
@@ -289,13 +396,26 @@ function withIdsInFields(fields, content, newId) {
   return Object.fromEntries(entries);
 }
 function withIdsIn(field, value, newId) {
-  if (field.kind === "group" && isContent(value)) {
-    return withIdsInFields(field.fields, value, newId);
-  }
-  if (field.kind === "collection" && Array.isArray(value)) {
-    return withIdsInRecords(field, value.filter(isContent), newId);
+  switch (field.kind) {
+    case "group":
+      return isContentObject(value) ? withIdsInFields(field.fields, value, newId) : value;
+    case "collection":
+      return Array.isArray(value) ? withIdsInRecords(field, value.filter(isContentObject), newId) : value;
+    case "text":
+    case "richText":
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "url":
+    case "time":
+    case "reference":
+    case "references":
+      return value;
   }
-  return value;
 }
 function withIdsInRecords(collection2, records, newId) {
   const taken = /* @__PURE__ */ new Set();
@@ -308,9 +428,6 @@ function withIdsInRecords(collection2, records, newId) {
     return { ...fields, [RECORD_ID_KEY]: id };
   });
 }
-function isContent(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/schema/reference-checks.ts
 function missingRecordIssues(schema, content) {
@@ -334,7 +451,7 @@ function issuesInField(field, value, path, idsOf) {
     case "references":
       return missingIds(stringsOf(value), field, path, idsOf);
     case "group":
-      return isContent2(value) ? issuesInFields(field.fields, value, path, idsOf) : [];
+      return isContentObject(value) ? issuesInFields(field.fields, value, path, idsOf) : [];
     case "collection":
       return recordsOf(value).flatMap(
         (record, index) => issuesInFields(field.item, record, [...path, index], idsOf)
@@ -364,22 +481,19 @@ function recordIdsAt(schema, content, path) {
   return new Set(ids.filter((id) => typeof id === "string"));
 }
 function recordsOf(value) {
-  return Array.isArray(value) ? value.filter(isContent2) : [];
+  return Array.isArray(value) ? value.filter(isContentObject) : [];
 }
 function stringsOf(value) {
   const list = Array.isArray(value) ? value : [];
   return list.filter((id) => typeof id === "string");
 }
-function isContent2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/schema/parse-content.ts
 var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 var TIME_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d$/u;
 var GRAPHEMES = new Intl.Segmenter("ru-RU", { granularity: "grapheme" });
 function formatFieldPath(path) {
-  return path.join(".");
+  return path.join(FIELD_PATH_SEPARATOR);
 }
 function countCharacters(text2) {
   return [...GRAPHEMES.segment(text2)].length;
@@ -393,7 +507,7 @@ function parseContent(schema, input) {
   };
 }
 function parseFields(fields, input, path) {
-  if (!isRecord(input)) {
+  if (!isJsonObject(input)) {
     return invalidType(defaultContent(fields), path);
   }
   const parsedFields = Object.entries(fields).map(([name, field]) => {
@@ -457,11 +571,11 @@ function parseText(field, input, path) {
   return valid(input);
 }
 function parseRichText(field, input, path) {
-  const read = typeof input === "string" ? richTextOf(input) : readRichText(input);
-  if (read === void 0) {
+  const read2 = typeof input === "string" ? richTextOf(input) : readRichText(input);
+  if (read2 === void 0) {
     return invalidType(defaultValue(field), path);
   }
-  const text2 = field.inline === true ? asOneParagraph(read) : read;
+  const text2 = field.inline === true ? asOneParagraph(read2) : read2;
   const hasUnsupportedLink = linkAddressesOf(text2).some(
     (href) => linkTargetOf(href) === void 0
   );
@@ -514,12 +628,12 @@ function parseImage(field, input, path) {
   if (input === null) {
     return valid(null);
   }
-  const src = isRecord(input) ? input["src"] : void 0;
-  const alt = isRecord(input) ? input["alt"] : void 0;
+  const src = isJsonObject(input) ? input["src"] : void 0;
+  const alt = isJsonObject(input) ? input["alt"] : void 0;
   if (typeof src !== "string" || typeof alt !== "string") {
     return invalidType(defaultValue(field), path);
   }
-  const focus = isRecord(input) ? focusOf(input["focus"]) : void 0;
+  const focus = isJsonObject(input) ? focusOf(input["focus"]) : void 0;
   const image2 = focus === void 0 ? { src, alt } : { src, alt, focus };
   if (src.trim() === "") {
     return { value: image2, issues: [{ path, code: "missing-image-src" }] };
@@ -530,7 +644,7 @@ function parseLink(field, input, path) {
   if (input === null) {
     return valid(null);
   }
-  if (!isRecord(input)) {
+  if (!isJsonObject(input)) {
     return invalidType(defaultValue(field), path);
   }
   const { text: text2, href } = input;
@@ -619,7 +733,7 @@ function parseCollection(field, input, path) {
 }
 function parseRecord(field, input, path) {
   const parsed = parseFields(field.item, input, path);
-  const id = isRecord(input) ? input[RECORD_ID_KEY] : void 0;
+  const id = isJsonObject(input) ? input[RECORD_ID_KEY] : void 0;
   if (!isRecordId(id)) return parsed;
   return {
     value: { ...parsed.value, [RECORD_ID_KEY]: id },
@@ -644,7 +758,7 @@ function parseReferences(field, input, path) {
   return valid(ids);
 }
 function focusOf(input) {
-  if (!isRecord(input)) return void 0;
+  if (!isJsonObject(input)) return void 0;
   const { x, y } = input;
   const isInside = isFraction(x) && isFraction(y);
   return isInside ? { x, y } : void 0;
@@ -659,9 +773,6 @@ function isCalendarDate(value) {
   const time2 = Date.parse(`${value}T00:00:00Z`);
   return !Number.isNaN(time2) && new Date(time2).toISOString().startsWith(value);
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function valid(value) {
   return { value, issues: [] };
 }
@@ -675,45 +786,6 @@ function editable() {
   return (...path) => ({ [FIELD_PATH_ATTRIBUTE]: formatFieldPath(path) });
 }
 
-// src/schema/field-paths.ts
-var RECORD_INDEX_PATTERN = /^\d+$/u;
-function resolveFieldPath(schema, text2) {
-  return resolveInFields(schema, text2.split("."), []);
-}
-function resolveInFields(fields, segments, parentPath) {
-  const [name, ...rest] = segments;
-  const field = name !== void 0 && Object.hasOwn(fields, name) ? fields[name] : void 0;
-  if (name === void 0 || field === void 0) {
-    return void 0;
-  }
-  const path = [...parentPath, name];
-  if (rest.length === 0) {
-    return { kind: "field", path, field };
-  }
-  return resolveInsideField(field, rest, path);
-}
-function resolveInsideField(field, segments, path) {
-  if (field.kind === "group") {
-    return resolveInFields(field.fields, segments, path);
-  }
-  if (field.kind === "collection") {
-    return resolveInCollection(field, segments, path);
-  }
-  return void 0;
-}
-function resolveInCollection(collection2, segments, collectionPath) {
-  const [indexText, ...rest] = segments;
-  if (indexText === void 0 || !RECORD_INDEX_PATTERN.test(indexText)) {
-    return void 0;
-  }
-  const index = Number(indexText);
-  const recordPath = [...collectionPath, index];
-  if (rest.length === 0) {
-    return { kind: "record", path: recordPath, collection: collection2, index };
-  }
-  return resolveInFields(collection2.item, rest, recordPath);
-}
-
 // src/schema/reveal-markers.ts
 var REVEAL_ATTRIBUTE = "data-cms-reveal";
 var REVEALED_ATTRIBUTE = "data-cms-revealed";
@@ -787,125 +859,185 @@ function openingHoursField(options = {}) {
 }
 
 // src/schema/read-fields.ts
+var TITLE_KINDS = /* @__PURE__ */ new Set([
+  "text",
+  "link"
+]);
 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;
+  const reading = checkFields(input);
+  return reading.status === "read" ? reading.fields : void 0;
+}
+function checkFields(input) {
+  const reading = readFieldsAt(input, []);
+  if (!reading.isRead) return { status: "invalid", problem: reading.problem };
+  const problem = firstUnknownCollection(reading.value, reading.value, []);
+  return problem === void 0 ? { status: "read", fields: reading.value } : { status: "invalid", problem };
+}
+function readFieldsAt(input, path) {
+  if (!isJsonObject(input)) return refused(path, "not-fields");
+  const fields = {};
+  for (const [name, value] of Object.entries(input)) {
+    const fieldPath = [...path, name];
+    if (!isFieldName(name)) return refused(fieldPath, "invalid-name");
+    const field = readField(value, fieldPath);
+    if (!field.isRead) return field;
+    fields[name] = field.value;
+  }
+  return read(fields);
 }
-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 readField(input, path) {
+  if (!isJsonObject(input)) return refused(path, "not-fields");
+  const { kind, label } = input;
+  if (typeof label !== "string") return refused(path, "invalid-label");
+  if (!isFieldKind(kind)) return refused(path, "unknown-kind");
+  return readFieldOfKind({ kind, label, input, path });
 }
-function readFieldOfKind(kind, label, input) {
+function readFieldOfKind(field) {
+  const { kind, label, input, path } = field;
   switch (kind) {
     case "text":
-      return {
-        kind,
-        label,
-        ...optional("multiline", input["multiline"], isBoolean),
-        ...optional("maxLength", input["maxLength"], isCount)
-      };
+      return withOptions({ kind, label }, path, [
+        optional("multiline", input, isBoolean),
+        optional("maxLength", input, isCount)
+      ]);
     case "richText":
-      return {
-        kind,
-        label,
-        ...optional("inline", input["inline"], isBoolean),
-        ...optional("maxLength", input["maxLength"], isCount)
-      };
+      return withOptions({ kind, label }, path, [
+        optional("inline", input, isBoolean),
+        optional("maxLength", input, isCount)
+      ]);
     case "number":
-      return {
-        kind,
-        label,
-        ...optional("min", input["min"], isNumber),
-        ...optional("max", input["max"], isNumber)
-      };
+      return withOptions({ kind, label }, path, [
+        optional("min", input, isNumber),
+        optional("max", input, isNumber)
+      ]);
     case "date":
     case "image":
     case "link":
     case "toggle":
     case "url":
     case "time":
-      return { kind, label };
+      return read({ kind, label });
     case "choice":
     case "choices":
-      return readChoiceField(kind, label, input["options"]);
+      return readChoiceField({ kind, label, input, path });
     case "reference":
     case "references":
-      return readReferenceField(kind, label, input["collection"]);
+      return readReferenceField({ kind, label, input, path });
     case "group":
-      return readGroupField(label, input["fields"]);
+      return readGroupField({ kind, label, input, path });
     case "collection":
-      return readCollectionField(label, input);
+      return readCollectionField({ kind, label, input, path });
   }
 }
-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 }) => ({
+function readChoiceField(field) {
+  const { kind, label, input, path } = field;
+  const options = input["options"];
+  const isOptionList = Array.isArray(options) && options.every(isChoiceOption);
+  if (!isOptionList) return refused(path, "invalid-choice-options");
+  const knownOptions = options.map(({ value, label: optionLabel }) => ({
     value,
     label: optionLabel
   }));
-  return { kind, label, options: read };
+  return read({ kind, label, options: knownOptions });
+}
+function readReferenceField(field) {
+  const { kind, label, input, path } = field;
+  const collection2 = input["collection"];
+  if (typeof collection2 !== "string") {
+    return refused(path, "unknown-collection");
+  }
+  return read({ kind, label, collection: collection2 });
+}
+function readGroupField(field) {
+  const { kind, label, input, path } = field;
+  const fields = readFieldsAt(input["fields"], path);
+  return fields.isRead ? read({ kind, label, fields: fields.value }) : fields;
+}
+function readCollectionField(field) {
+  const { kind, label, input, path } = field;
+  const item = readFieldsAt(input["item"], path);
+  if (!item.isRead) return item;
+  if (RECORD_ID_KEY in item.value) {
+    return refused([...path, RECORD_ID_KEY], "record-id-field");
+  }
+  const itemTitle = input["itemTitle"];
+  if (itemTitle === void 0) return read({ kind, label, item: item.value });
+  const titleField = typeof itemTitle === "string" && Object.hasOwn(item.value, itemTitle) ? item.value[itemTitle] : void 0;
+  const canTitleRecord = titleField !== void 0 && TITLE_KINDS.has(titleField.kind);
+  if (typeof itemTitle !== "string" || !canTitleRecord) {
+    return refused(path, "invalid-item-title");
+  }
+  return read({ kind, label, item: item.value, itemTitle });
 }
-function readReferenceField(kind, label, collection2) {
-  return typeof collection2 === "string" ? { kind, label, collection: collection2 } : void 0;
+function firstUnknownCollection(schema, fields, path) {
+  for (const [name, field] of Object.entries(fields)) {
+    const problem = unknownCollectionIn(schema, field, [...path, name]);
+    if (problem !== void 0) return problem;
+  }
+  return void 0;
+}
+function unknownCollectionIn(schema, field, path) {
+  switch (field.kind) {
+    case "reference":
+    case "references":
+      return referencesCollection(schema, field) ? void 0 : { path, reason: "unknown-collection" };
+    case "group":
+      return firstUnknownCollection(schema, field.fields, path);
+    case "collection":
+      return firstUnknownCollection(schema, field.item, path);
+    case "text":
+    case "richText":
+    case "number":
+    case "date":
+    case "image":
+    case "link":
+    case "toggle":
+    case "choice":
+    case "choices":
+    case "url":
+    case "time":
+      return void 0;
+  }
 }
-function readGroupField(label, input) {
-  const fields = readFields(input);
-  return fields === void 0 ? void 0 : { kind: "group", label, fields };
+function referencesCollection(schema, field) {
+  return collectionFieldAt(schema, field.collection) !== void 0;
 }
-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 withOptions(field, path, options) {
+  const isEveryOptionRead = options.every((option) => option !== void 0);
+  if (!isEveryOptionRead) return refused(path, "invalid-option");
+  return read(Object.assign({}, field, ...options));
 }
-function optional(key, value, isOfKind) {
-  if (!isOfKind(value)) return {};
+function optional(key, input, isOfKind) {
+  const value = input[key];
+  if (value === void 0) return {};
+  if (!isOfKind(value)) return void 0;
   return { [key]: value };
 }
-var FIELD_KINDS = /* @__PURE__ */ new Set([
-  "text",
-  "richText",
-  "number",
-  "date",
-  "image",
-  "link",
-  "toggle",
-  "choice",
-  "choices",
-  "url",
-  "time",
-  "reference",
-  "references",
-  "group",
-  "collection"
-]);
+var FIELD_KINDS = {
+  text: true,
+  richText: true,
+  number: true,
+  date: true,
+  image: true,
+  link: true,
+  toggle: true,
+  choice: true,
+  choices: true,
+  url: true,
+  time: true,
+  reference: true,
+  references: true,
+  group: true,
+  collection: true
+};
 function isFieldKind(value) {
-  return typeof value === "string" && FIELD_KINDS.has(value);
+  return typeof value === "string" && Object.hasOwn(FIELD_KINDS, value);
 }
-function isChoiceOption(value) {
-  return isRecord2(value) && typeof value["value"] === "string" && typeof value["label"] === "string";
+function isFieldName(name) {
+  return name !== "" && !name.includes(FIELD_PATH_SEPARATOR) && !isRecordIndex(name);
 }
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isChoiceOption(value) {
+  return isJsonObject(value) && typeof value["value"] === "string" && typeof value["label"] === "string";
 }
 function isBoolean(value) {
   return typeof value === "boolean";
@@ -916,6 +1048,12 @@ function isNumber(value) {
 function isCount(value) {
   return isNumber(value) && Number.isInteger(value) && value >= 0;
 }
+function read(value) {
+  return { isRead: true, value };
+}
+function refused(path, reason) {
+  return { isRead: false, problem: { path, reason } };
+}
 
 // src/schema/site-config.ts
 var SITE_CONFIG_FILE = "seamlet.json";
@@ -927,7 +1065,7 @@ function isSiteId(value) {
   return typeof value === "string" && value.length <= LONGEST_SITE_ID && SITE_ID.test(value);
 }
 function readSiteConfig(input) {
-  const fields = isRecord3(input) ? input : {};
+  const fields = isJsonObject(input) ? input : {};
   const { id, title } = fields;
   const cms = originOf(fields["cms"]);
   const hasId = isSiteId(id);
@@ -949,27 +1087,43 @@ function originOf(value) {
   const url2 = new URL(value);
   return WEB_PROTOCOLS.has(url2.protocol) ? url2.origin : void 0;
 }
-function isText(value) {
-  return typeof value === "string" && value.trim() !== "";
-}
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/schema/site-description.ts
 var SITE_DESCRIPTION_PATH = "/seamlet/site.json";
 var PAGE_PATH = /^(\/[a-z0-9][a-z0-9-]*)+$/u;
 var HOME_PAGE_PATH = "/";
 function readSiteDescription(input) {
-  if (!isRecord4(input)) return void 0;
+  const reading = checkSiteDescription(input);
+  return reading.status === "read" ? reading.description : void 0;
+}
+function checkSiteDescription(input) {
+  if (!isJsonObject(input)) return invalid([{ code: "not-a-description" }]);
   const { id, title } = input;
-  const schema = readFields(input["schema"]);
-  const isNamed = isSiteId(id) && isText2(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 };
+  const nameProblems = namingProblems(id, title);
+  const schema = checkFields(input["schema"]);
+  if (schema.status === "invalid") {
+    const { problem } = schema;
+    return invalid([...nameProblems, { code: "invalid-schema", problem }]);
+  }
+  const initial = parseContent(schema.fields, input["initialContent"]);
+  const pages = checkPages(schema.fields, input["pages"]);
+  const problems = [
+    ...nameProblems,
+    ...initialContentProblems(initial.issues),
+    ...pages.problems
+  ];
+  const isNamed = isSiteId(id) && isText(title);
+  if (!isNamed || pages.pages === void 0 || problems.length > 0) {
+    return invalid(problems);
+  }
+  const description = {
+    id,
+    title,
+    schema: schema.fields,
+    initialContent: initial.content,
+    pages: pages.pages
+  };
+  return { status: "read", description };
 }
 function isSearchTextsGroup(schema, path) {
   const target = resolveFieldPath(schema, path);
@@ -977,30 +1131,53 @@ function isSearchTextsGroup(schema, path) {
   const { title, description } = target.field.fields;
   return title?.kind === "text" && description?.kind === "text";
 }
-function readPages(schema, input) {
-  if (!Array.isArray(input)) return void 0;
+function namingProblems(id, title) {
+  const idProblems = isSiteId(id) ? [] : [{ code: "invalid-id" }];
+  const titleProblems = isText(title) ? [] : [{ code: "invalid-title" }];
+  return [...idProblems, ...titleProblems];
+}
+function initialContentProblems(issues) {
+  return issues.length > 0 ? [{ code: "invalid-initial-content", issues }] : [];
+}
+function checkPages(schema, input) {
+  if (!Array.isArray(input) || input.length === 0) {
+    return { pages: void 0, problems: [{ code: "no-pages" }] };
+  }
   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;
+  const readings = entries.map((entry) => readPage(schema, entry));
+  const pageProblems = readings.flatMap(
+    (reading, index) => typeof reading === "string" ? [{ code: "invalid-page", index, reason: reading }] : []
+  );
+  const pages = readings.filter((reading) => typeof reading !== "string");
+  const problems = [...pageProblems, ...orderProblems(pages)];
+  const [first, ...rest] = pages;
+  const isSound = problems.length === 0 && first !== void 0;
+  return { pages: isSound ? [first, ...rest] : void 0, problems };
+}
+function orderProblems(pages) {
+  const paths = pages.map((page) => page.path);
+  const repeated = paths.filter((path, index) => paths.indexOf(path) !== index);
+  const isHomeMissing = paths.length > 0 && paths[0] !== HOME_PAGE_PATH;
+  const homeProblems = isHomeMissing ? [{ code: "home-page-not-first" }] : [];
+  const repeatProblems = [...new Set(repeated)].map(
+    (path) => ({ code: "repeated-page-path", path })
+  );
+  return [...homeProblems, ...repeatProblems];
 }
 function readPage(schema, input) {
-  if (!isRecord4(input)) return void 0;
+  if (!isJsonObject(input)) return "not-a-page";
   const { path, title, searchTexts } = input;
-  const isPath = typeof path === "string" && (path === HOME_PAGE_PATH || PAGE_PATH.test(path));
-  if (!isPath || !isText2(title)) return void 0;
+  if (!isPagePath(path)) return "invalid-path";
+  if (!isText(title)) return "invalid-title";
   if (searchTexts === void 0) return { path, title };
   const isSearchTexts = typeof searchTexts === "string" && isSearchTextsGroup(schema, searchTexts);
-  return isSearchTexts ? { path, title, searchTexts } : void 0;
+  return isSearchTexts ? { path, title, searchTexts } : "invalid-search-texts";
 }
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isPagePath(path) {
+  return typeof path === "string" && (path === HOME_PAGE_PATH || PAGE_PATH.test(path));
 }
-function isText2(value) {
-  return typeof value === "string" && value.trim() !== "";
+function invalid(problems) {
+  return { status: "invalid", problems };
 }
 
 export {
@@ -1022,13 +1199,17 @@ export {
   collection,
   defaultValue,
   defaultContent,
+  resolveFieldPath,
+  isJsonObject,
   linkTargetOf,
+  safeHref,
   hrefOf,
   richTextOf,
   plainTextOf,
   asOneParagraph,
   readRichText,
   normalizedLine,
+  linesOf,
   RECORD_ID_KEY,
   isRecordId,
   newRecord,
@@ -1040,7 +1221,6 @@ export {
   parseContent,
   FIELD_PATH_ATTRIBUTE,
   editable,
-  resolveFieldPath,
   REVEAL_ATTRIBUTE,
   REVEALED_ATTRIBUTE,
   REVEAL_EVENT,
@@ -1050,10 +1230,13 @@ export {
   WEEKDAYS,
   openingHoursField,
   readFields,
+  checkFields,
   SITE_CONFIG_FILE,
   isSiteId,
   readSiteConfig,
   SITE_DESCRIPTION_PATH,
+  HOME_PAGE_PATH,
   readSiteDescription,
+  checkSiteDescription,
   isSearchTextsGroup
 };