@wocart/theme 1.5.0 → 2.0.0

package/dist/operations.js

@@ -7,10 +7,19 @@
  * build is one `validatePageData` reads without a report, and that the
  * renderer renders as the writer saw it. How an editor lets a merchant drag,
  * select or undo is the editor's own.
+ *
+ * Blocks: a fixed block is never removed, moved, duplicated or
+ * hidden; a required block never drops below its slot's minimum; a component
+ * goes only where its `placement` allows; slots, surfaces, documents and
+ * nesting stay within their caps. Operations on a document assume it was
+ * completed (`completePage`) when it was opened.
  */
+import { THEME_LIMITS, composesSurface, placementAllows, slotCap, surfaceRules } from "./blocks.js";
 import { surfaceCovers } from "./composition.js";
 import { checkStoredValue, hasFallback, ownValue } from "./instances.js";
 import { ComponentInstanceSchema } from "./schemas.js";
+import { styleSizeProblem } from "./style.js";
+import { completeInstance } from "./surface-document.js";
 /**
  * A new instance id: `cmp_` and 16 random hex digits. Operations refuse an id
  * the document already holds, so a collision is reported, never written.
@@ -20,6 +29,7 @@ export function newInstanceId() {
     return `cmp_${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isTheme = (value) => isRecord(value) && isRecord(value.components);
 const definitionOf = (theme, type) => Object.hasOwn(theme.components, type) ? theme.components[type] : undefined;
 const refuse = (code, message, path = "") => ({
     ok: false,
@@ -37,17 +47,24 @@ function slotLists(node) {
     }
     return lists;
 }
-/** Every instance with its location, depth first. */
-function* walk(list, parent, slot) {
+/** Every instance with its location, depth first; fixed blocks after their owner's slots. */
+function* walk(list, parent, slot, depth) {
     for (const [index, instance] of list.entries()) {
-        yield { instance, parent, slot, index };
-        for (const [name, children] of slotLists(instance))
-            yield* walk(children, instance.id, name);
+        yield { instance, parent, slot, index, depth };
+        yield* walkInside(instance, depth);
+    }
+}
+function* walkInside(instance, depth) {
+    for (const [name, children] of slotLists(instance))
+        yield* walk(children, instance.id, name, depth + 1);
+    for (const [name, block] of Object.entries(instance.fixed ?? {})) {
+        yield { instance: block, parent: instance.id, slot: null, index: 0, fixed: name, depth: depth + 1 };
+        yield* walkInside(block, depth + 1);
     }
 }
 /** Where `id` is in the document, or `null`. */
 export function findInstance(page, id) {
-    for (const location of walk(page.sections, null, null)) {
+    for (const location of walk(page.sections, null, null, 0)) {
         if (location.instance.id === id)
             return location;
     }
@@ -55,10 +72,29 @@ export function findInstance(page, id) {
 }
 function documentIds(page) {
     const ids = new Set();
-    for (const { instance } of walk(page.sections, null, null))
+    for (const { instance } of walk(page.sections, null, null, 0))
         ids.add(instance.id);
     return ids;
 }
+/** Levels an instance tree reaches below itself (a leaf: 0). */
+function height(node) {
+    let deepest = 0;
+    for (const [, list] of slotLists(node))
+        for (const child of list)
+            deepest = Math.max(deepest, 1 + height(child));
+    for (const block of Object.values(node.fixed ?? {}))
+        deepest = Math.max(deepest, 1 + height(block));
+    return deepest;
+}
+const countTree = (node) => {
+    let count = 1;
+    for (const [, list] of slotLists(node))
+        for (const child of list)
+            count += countTree(child);
+    for (const block of Object.values(node.fixed ?? {}))
+        count += countTree(block);
+    return count;
+};
 /**
  * The editable list a placement names, in a copy of the document: the sections,
  * or a parent's slot. The default slot is normalized to `children` (the order
@@ -86,35 +122,83 @@ function targetList(page, placement) {
     parent.slots[slot] ??= [];
     return parent.slots[slot];
 }
-/** Can `type` go into the placement's slot, given what is already there? */
-function placementIssue(theme, page, type, placement, occupied) {
+function listRules(theme, page, parentId, slotName) {
+    if (parentId === null) {
+        const rules = surfaceRules(theme, page.surface);
+        return { name: "sections", cap: slotCap(rules, THEME_LIMITS.sections), required: rules.required ?? [], slot: null };
+    }
+    const parent = findInstance(page, parentId);
+    const definition = parent === null ? undefined : definitionOf(theme, parent.instance.type);
+    const slot = (definition?.slots ?? []).find((candidate) => candidate.name === (slotName ?? "default"));
+    if (slot === undefined)
+        return null;
+    return { name: slot.name, cap: slotCap(slot, THEME_LIMITS.slotInstances), required: slot.required ?? [], slot };
+}
+const shownOfType = (list, type) => list.filter((instance) => instance.type === type && instance.hidden !== true).length;
+/** Whether taking `instance` out of view in its list would leave the list short of a required type. */
+function leavesRequiredShort(rules, list, instance) {
+    if (rules === null || instance.hidden === true)
+        return null;
+    const entry = rules.required.find((candidate) => candidate.type === instance.type);
+    if (entry === undefined)
+        return null;
+    return shownOfType(list, instance.type) - 1 < (entry.min ?? 1) ? entry : null;
+}
+/** Can `type` go into the placement's list, given what is already there? */
+function placementIssue(theme, page, type, placement, list) {
+    const definition = definitionOf(theme, type);
     if (placement.parent === undefined) {
         if (placement.slot !== undefined)
             return refuse("unknown-slot", "the top-level sections have no slots");
-        return null;
+        if (!placementAllows(definition?.placement, "section"))
+            return refuse("not-placeable", `"${type}" is placed only inside another component`);
     }
-    const location = findInstance(page, placement.parent);
-    if (location === null)
-        return refuse("unknown-instance", `no instance "${placement.parent}" in the document`);
-    const definition = definitionOf(theme, location.instance.type);
-    if (definition === undefined)
-        return refuse("unknown-type", `"${location.instance.type}" is not in the theme catalog`);
-    const name = placement.slot ?? "default";
-    const slot = (definition.slots ?? []).find((candidate) => candidate.name === name);
-    if (slot === undefined)
-        return refuse("unknown-slot", `"${definition.type}" declares no slot "${name}"`);
-    if (slot.allow !== undefined && !slot.allow.includes(type)) {
-        return refuse("not-allowed", `"${type}" is not allowed in slot "${name}" of "${definition.type}"`);
+    else {
+        const location = findInstance(page, placement.parent);
+        if (location === null)
+            return refuse("unknown-instance", `no instance "${placement.parent}" in the document`);
+        const parentDefinition = definitionOf(theme, location.instance.type);
+        if (parentDefinition === undefined)
+            return refuse("unknown-type", `"${location.instance.type}" is not in the theme catalog`);
+        const name = placement.slot ?? "default";
+        const slot = (parentDefinition.slots ?? []).find((candidate) => candidate.name === name);
+        if (slot === undefined)
+            return refuse("unknown-slot", `"${parentDefinition.type}" declares no slot "${name}"`);
+        if (slot.allow !== undefined && !slot.allow.includes(type)) {
+            return refuse("not-allowed", `"${type}" is not allowed in slot "${name}" of "${parentDefinition.type}"`);
+        }
+        if (slot.multiple === false && list.length >= 1) {
+            return refuse("slot-full", `slot "${name}" of "${parentDefinition.type}" holds at most one instance`);
+        }
+        if (!placementAllows(definition?.placement, "block"))
+            return refuse("not-placeable", `"${type}" is placed only as a section`);
     }
-    if (slot.multiple === false && occupied >= 1) {
-        return refuse("slot-full", `slot "${name}" of "${definition.type}" holds at most one instance`);
+    const rules = listRules(theme, page, placement.parent ?? null, placement.slot ?? null);
+    if (rules !== null && list.length >= rules.cap) {
+        return refuse("limit-exceeded", `${rules.name === "sections" ? "the surface" : `slot "${rules.name}"`} holds at most ${rules.cap}`);
+    }
+    const entry = rules?.required.find((candidate) => candidate.type === type);
+    if (entry?.max !== undefined && list.filter((instance) => instance.type === type).length >= entry.max) {
+        return refuse("required-block", `"${type}" appears at most ${entry.max} time(s) in ${rules.name === "sections" ? "the surface" : `slot "${rules.name}"`}`);
+    }
+    return null;
+}
+/** Whether a tree may sit at `depth` (its root's level), and the document may grow by it. */
+function sizeIssue(page, tree, depth) {
+    if (depth + height(tree) > THEME_LIMITS.depth) {
+        return refuse("limit-exceeded", `nesting goes at most ${THEME_LIMITS.depth} levels below a section`);
+    }
+    if (documentIds(page).size + countTree(tree) > THEME_LIMITS.documentInstances) {
+        return refuse("limit-exceeded", `a document holds at most ${THEME_LIMITS.documentInstances} instances`);
     }
     return null;
 }
+const placementDepth = (page, placement) => placement.parent === undefined ? 0 : (findInstance(page, placement.parent)?.depth ?? 0) + 1;
 /**
  * An instance tree a writer may store, on this surface: known types, declared
  * props with values their fields accept, required fields filled, slots used as
- * declared, every component available on the surface, and ids unique among
+ * declared with their required types present, fixed blocks declared and of
+ * their type, every component available on the surface, and ids unique among
  * themselves and `taken`. Returns the first problem.
  */
 function treeIssue(theme, node, surface, taken, path) {
@@ -137,6 +221,9 @@ function treeIssue(theme, node, surface, taken, path) {
         const checked = checkStoredValue(field, value);
         if (!checked.ok)
             return { path: `${path}.props.${key}`, code: "invalid-props", message: `"${key}" ${checked.message}` };
+        const unsized = field.kind === "style" ? styleSizeProblem(theme.style, value) : null;
+        if (unsized !== null)
+            return { path: `${path}.props.${key}`, code: "invalid-props", message: `"${key}" ${unsized}` };
     }
     for (const field of fields.values()) {
         if (field.required === true && ownValue(props, field.key) === undefined && !hasFallback(field)) {
@@ -144,7 +231,8 @@ function treeIssue(theme, node, surface, taken, path) {
         }
     }
     const slots = new Map((definition.slots ?? []).map((slot) => [slot.name, slot]));
-    for (const [name, list, listPath] of slotLists(node)) {
+    const lists = new Map(slotLists(node).map(([name, list, listPath]) => [name, { list, listPath }]));
+    for (const [name, { list, listPath }] of lists) {
         const slot = slots.get(name);
         if (slot === undefined) {
             if (list.length === 0)
@@ -154,16 +242,54 @@ function treeIssue(theme, node, surface, taken, path) {
         if (slot.multiple === false && list.length > 1) {
             return { path: `${path}.${listPath}`, code: "slot-full", message: `slot "${name}" of "${node.type}" holds at most one instance` };
         }
+        const cap = slotCap(slot, THEME_LIMITS.slotInstances);
+        if (list.length > cap) {
+            return { path: `${path}.${listPath}`, code: "limit-exceeded", message: `slot "${name}" of "${node.type}" holds at most ${cap}` };
+        }
         for (const [index, child] of list.entries()) {
             const childPath = `${path}.${listPath}[${index}]`;
             if (slot.allow !== undefined && !slot.allow.includes(child.type)) {
                 return { path: childPath, code: "not-allowed", message: `"${child.type}" is not allowed in slot "${name}" of "${node.type}"` };
             }
+            if (!placementAllows(definitionOf(theme, child.type)?.placement, "block")) {
+                return { path: childPath, code: "not-placeable", message: `"${child.type}" is placed only as a section` };
+            }
             const issue = treeIssue(theme, child, surface, taken, childPath);
             if (issue !== null)
                 return issue;
         }
     }
+    for (const slot of slots.values()) {
+        const listPath = slot.name === "default" ? "children" : `slots.${slot.name}`;
+        const issue = requiredCountIssue(slot.required, lists.get(slot.name)?.list ?? [], `${path}.${listPath}`, `slot "${slot.name}" of "${node.type}"`);
+        if (issue !== null)
+            return issue;
+    }
+    const declared = new Map((definition.fixed ?? []).map((block) => [block.name, block]));
+    for (const [name, block] of Object.entries(node.fixed ?? {})) {
+        const blockPath = `${path}.fixed.${name}`;
+        const expected = declared.get(name);
+        if (expected === undefined)
+            return { path: blockPath, code: "fixed-block", message: `"${node.type}" places no fixed block "${name}"` };
+        if (block.type !== expected.type)
+            return { path: `${blockPath}.type`, code: "fixed-block", message: `the fixed block "${name}" is a "${expected.type}", not a "${block.type}"` };
+        if (block.hidden === true)
+            return { path: `${blockPath}.hidden`, code: "fixed-block", message: `the fixed block "${name}" cannot be hidden` };
+        const issue = treeIssue(theme, block, surface, taken, blockPath);
+        if (issue !== null)
+            return issue;
+    }
+    return null;
+}
+function requiredCountIssue(required, list, path, where) {
+    for (const { type, min = 1, max } of required ?? []) {
+        const shown = shownOfType(list, type);
+        if (shown < min)
+            return { path, code: "required-block", message: `${where} must show at least ${min} "${type}"` };
+        if (max !== undefined && list.filter((instance) => instance.type === type).length > max) {
+            return { path, code: "required-block", message: `${where} holds at most ${max} "${type}"` };
+        }
+    }
     return null;
 }
 function parseInstance(instance) {
@@ -184,9 +310,11 @@ function indexIssue(index, length) {
 }
 /**
  * Insert a new instance — from `createInstance` or `instantiatePreset` — at a
- * placement. Refused when the component is not insertable or not available on
- * the document's surface, when the slot does not take it, or when any id is
- * already in the document.
+ * placement, completed with its fixed and required blocks. Refused when the
+ * component is not insertable, not available on the document's surface, not
+ * placeable there, when the list is full or already holds the most of its
+ * type, when the document would pass its caps, or when any id is already in
+ * the document.
  */
 export function insertInstance(theme, page, instance, placement = {}) {
     const parsed = parseInstance(instance);
@@ -198,6 +326,8 @@ export function insertInstance(theme, page, instance, placement = {}) {
     if (definition.capabilities?.insertable === false) {
         return refuse("not-insertable", `"${parsed.type}" is not inserted by editors`);
     }
+    const existing = documentIds(page);
+    const tree = completeInstance(theme, parsed, new Set(existing));
     const next = structuredClone(page);
     const list = targetList(next, placement);
     if (list === null)
@@ -205,58 +335,85 @@ export function insertInstance(theme, page, instance, placement = {}) {
     const position = indexIssue(placement.index, list.length);
     if (position !== null)
         return position;
-    const slotProblem = placementIssue(theme, next, parsed.type, placement, list.length);
+    const slotProblem = placementIssue(theme, next, tree.type, placement, list);
     if (slotProblem !== null)
         return slotProblem;
-    const issue = treeIssue(theme, parsed, next.surface, documentIds(page), "instance");
+    const size = sizeIssue(page, tree, placementDepth(page, placement));
+    if (size !== null)
+        return size;
+    const issue = treeIssue(theme, tree, next.surface, existing, "instance");
     if (issue !== null)
         return { ok: false, issue };
-    list.splice(placement.index ?? list.length, 0, structuredClone(parsed));
+    list.splice(placement.index ?? list.length, 0, tree);
     return { ok: true, page: next };
 }
-/** Remove an instance and everything inside it. */
-export function removeInstance(page, id) {
+export function removeInstance(...args) {
+    const [theme, page, id] = isTheme(args[0]) ? args : [null, args[0], args[1]];
     const next = structuredClone(page);
     const location = findInstance(next, id);
     if (location === null)
         return refuse("unknown-instance", `no instance "${id}" in the document`);
+    if (location.fixed !== undefined)
+        return refuse("fixed-block", `"${id}" is placed by its component's code and cannot be removed`);
     const list = location.parent === null
         ? next.sections
         : targetList(next, { parent: location.parent, slot: location.slot ?? "default" });
     if (list === null)
         return refuse("unknown-instance", `no instance "${location.parent}" in the document`);
+    if (theme !== null) {
+        const short = leavesRequiredShort(listRules(theme, next, location.parent, location.slot), list, location.instance);
+        if (short !== null)
+            return refuse("required-block", `"${location.instance.type}" is required here (at least ${short.min ?? 1})`);
+    }
     list.splice(list.findIndex((candidate) => candidate.id === id), 1);
     return { ok: true, page: next };
 }
 /**
  * Move an instance (with everything inside it) to a placement. `index` counts
  * positions in the destination after the instance has left its old place.
+ * A fixed block never moves; a required one moves only within its own list,
+ * unless enough of its type stay behind.
  */
 export function moveInstance(theme, page, id, placement = {}) {
     const location = findInstance(page, id);
     if (location === null)
         return refuse("unknown-instance", `no instance "${id}" in the document`);
+    if (location.fixed !== undefined)
+        return refuse("fixed-block", `"${id}" is placed by its component's code and cannot be moved`);
     if (placement.parent !== undefined) {
         if (placement.parent === id)
             return refuse("cycle", "an instance cannot be moved into itself");
-        for (const inner of walk([location.instance], null, null)) {
+        for (const inner of walk([location.instance], null, null, 0)) {
             if (inner.instance.id === placement.parent)
                 return refuse("cycle", `"${placement.parent}" is inside "${id}"`);
         }
     }
-    const removed = removeInstance(page, id);
-    if (!removed.ok)
-        return removed;
-    const next = removed.page;
+    const sameList = (placement.parent ?? null) === location.parent && (location.parent === null || (placement.slot ?? "default") === (location.slot ?? "default"));
+    if (!sameList) {
+        const from = location.parent === null ? page.sections : (slotLists(findInstance(page, location.parent).instance).find(([name]) => name === (location.slot ?? "default"))?.[1] ?? []);
+        const short = leavesRequiredShort(listRules(theme, page, location.parent, location.slot), from, location.instance);
+        if (short !== null)
+            return refuse("required-block", `"${location.instance.type}" is required where it is (at least ${short.min ?? 1})`);
+    }
+    const next = structuredClone(page);
+    const origin = location.parent === null ? next.sections : targetList(next, { parent: location.parent, slot: location.slot ?? "default" });
+    if (origin === null)
+        return refuse("unknown-instance", `no instance "${location.parent}" in the document`);
+    origin.splice(origin.findIndex((candidate) => candidate.id === id), 1);
     const list = targetList(next, placement);
     if (list === null)
         return refuse("unknown-instance", `no instance "${placement.parent}" in the document`);
     const position = indexIssue(placement.index, list.length);
     if (position !== null)
         return position;
-    const slotProblem = placementIssue(theme, next, location.instance.type, placement, list.length);
-    if (slotProblem !== null)
-        return slotProblem;
+    if (!sameList) {
+        const slotProblem = placementIssue(theme, next, location.instance.type, placement, list);
+        if (slotProblem !== null)
+            return slotProblem;
+        if (placementDepth(next, placement) + height(location.instance) > THEME_LIMITS.depth) {
+            return refuse("limit-exceeded", `nesting goes at most ${THEME_LIMITS.depth} levels below a section`);
+        }
+    }
     const surfaces = definitionOf(theme, location.instance.type)?.capabilities?.surfaces;
     if (surfaces !== undefined && !surfaces.some((entry) => surfaceCovers(entry, next.surface))) {
         return refuse("not-available", `"${location.instance.type}" cannot be placed on "${next.surface}"`);
@@ -267,14 +424,17 @@ export function moveInstance(theme, page, id, placement = {}) {
 /**
  * Copy an instance and everything inside it right after the original, every
  * copied instance with an id from `newId`. List items keep their ids: they
- * are unique within their list, not the document.
+ * are unique within their list, not the document. A fixed block is never
+ * copied.
  */
 export function duplicateInstance(theme, page, id, newId) {
     const location = findInstance(page, id);
     if (location === null)
         return refuse("unknown-instance", `no instance "${id}" in the document`);
+    if (location.fixed !== undefined)
+        return refuse("fixed-block", `"${id}" is placed by its component's code and cannot be copied`);
     const copy = structuredClone(location.instance);
-    for (const inner of walk([copy], null, null))
+    for (const inner of walk([copy], null, null, 0))
         inner.instance.id = newId();
     const placement = location.parent === null
         ? { index: location.index + 1 }
@@ -283,9 +443,12 @@ export function duplicateInstance(theme, page, id, newId) {
     const list = targetList(next, placement);
     if (list === null)
         return refuse("unknown-instance", `no instance "${location.parent}" in the document`);
-    const slotProblem = placementIssue(theme, next, copy.type, placement, list.length);
+    const slotProblem = placementIssue(theme, next, copy.type, placement, list);
     if (slotProblem !== null)
         return slotProblem;
+    const size = sizeIssue(page, copy, location.depth);
+    if (size !== null)
+        return size;
     const issue = treeIssue(theme, copy, next.surface, documentIds(page), "instance");
     if (issue !== null)
         return { ok: false, issue };
@@ -293,9 +456,9 @@ export function duplicateInstance(theme, page, id, newId) {
     return { ok: true, page: next };
 }
 /**
- * Change an instance's props: each value is checked by its field;
- * `undefined` removes the stored value, so the field falls back to its
- * content-pack text or default.
+ * Change an instance's props — a fixed block's too: each value is checked by
+ * its field; `undefined` removes the stored value, so the field falls back to
+ * its content-pack text or default.
  */
 export function setInstanceProps(theme, page, id, changes) {
     const next = structuredClone(page);
@@ -322,6 +485,9 @@ export function setInstanceProps(theme, page, id, changes) {
         const checked = checkStoredValue(field, value);
         if (!checked.ok)
             return refuse("invalid-props", `"${key}" ${checked.message}`, `props.${key}`);
+        const unsized = field.kind === "style" ? styleSizeProblem(theme.style, value) : null;
+        if (unsized !== null)
+            return refuse("invalid-props", `"${key}" ${unsized}`, `props.${key}`);
         props[key] = value;
     }
     if (Object.keys(props).length > 0)
@@ -330,12 +496,22 @@ export function setInstanceProps(theme, page, id, changes) {
         delete instance.props;
     return { ok: true, page: next };
 }
-/** Switch an instance off (kept, not rendered) or back on. */
-export function setInstanceHidden(page, id, hidden) {
+export function setInstanceHidden(...args) {
+    const [theme, page, id, hidden] = isTheme(args[0])
+        ? args
+        : [null, args[0], args[1], args[2]];
     const next = structuredClone(page);
     const location = findInstance(next, id);
     if (location === null)
         return refuse("unknown-instance", `no instance "${id}" in the document`);
+    if (hidden && location.fixed !== undefined)
+        return refuse("fixed-block", `"${id}" is placed by its component's code and cannot be hidden`);
+    if (hidden && theme !== null) {
+        const list = location.parent === null ? next.sections : (slotLists(findInstance(next, location.parent).instance).find(([name]) => name === (location.slot ?? "default"))?.[1] ?? []);
+        const short = leavesRequiredShort(listRules(theme, next, location.parent, location.slot), list, location.instance);
+        if (short !== null)
+            return refuse("required-block", `"${location.instance.type}" is required here and cannot be hidden`);
+    }
     if (hidden)
         location.instance.hidden = true;
     else
@@ -345,8 +521,9 @@ export function setInstanceHidden(page, id, hidden) {
 /**
  * Everything a writer must fix before saving a document for this theme —
  * the strict counterpart of `validatePageData`: an envelope for one of the
- * theme's surfaces when it declares any, and every section a tree the
- * operations would have built. An empty list means the document may be saved.
+ * theme's surfaces when it declares any, the surface's required sections
+ * shown and its cap kept, and every section a tree the operations would have
+ * built. An empty list means the document may be saved.
  */
 export function checkPageData(theme, input) {
     if (!isRecord(input) || input.version !== 1 || typeof input.surface !== "string" || !Array.isArray(input.sections)) {
@@ -354,14 +531,20 @@ export function checkPageData(theme, input) {
     }
     const issues = [];
     const surface = input.surface;
-    const declared = theme.surfaces ?? [];
-    if (declared.length > 0 && !declared.some((spec) => spec.key === surface)) {
-        issues.push({ path: "surface", code: "invalid-document", message: `"${surface}" is not a surface this theme declares` });
+    const declares = (theme.surfaces ?? []).length + (theme.areas ?? []).length > 0;
+    if (declares && !composesSurface(theme, surface)) {
+        issues.push({ path: "surface", code: "invalid-document", message: `"${surface}" is not a surface or area this theme declares` });
     }
     if (input.theme !== undefined && !(isRecord(input.theme) && input.theme.key === theme.key && typeof input.theme.version === "string" && input.theme.version.length > 0)) {
         issues.push({ path: "theme", code: "invalid-document", message: `\`theme\` must name this theme: { key: "${theme.key}", version }` });
     }
+    const rules = surfaceRules(theme, surface);
+    const cap = slotCap(rules, THEME_LIMITS.sections);
+    if (input.sections.length > cap) {
+        issues.push({ path: "sections", code: "limit-exceeded", message: `the surface holds at most ${cap} sections` });
+    }
     const taken = new Set();
+    const sections = [];
     input.sections.forEach((section, index) => {
         const path = `sections[${index}]`;
         const parsed = parseInstance(section);
@@ -369,9 +552,24 @@ export function checkPageData(theme, input) {
             issues.push({ ...parsed, path });
             return;
         }
+        sections.push(parsed);
+        if (!placementAllows(definitionOf(theme, parsed.type)?.placement, "section")) {
+            issues.push({ path, code: "not-placeable", message: `"${parsed.type}" is placed only inside another component` });
+            return;
+        }
+        if (height(parsed) > THEME_LIMITS.depth) {
+            issues.push({ path, code: "limit-exceeded", message: `nesting goes at most ${THEME_LIMITS.depth} levels below a section` });
+            return;
+        }
         const issue = treeIssue(theme, parsed, surface, taken, path);
         if (issue !== null)
             issues.push(issue);
     });
+    const required = requiredCountIssue(rules.required, sections, "sections", "the surface");
+    if (required !== null)
+        issues.push(required);
+    if (taken.size > THEME_LIMITS.documentInstances) {
+        issues.push({ path: "sections", code: "limit-exceeded", message: `a document holds at most ${THEME_LIMITS.documentInstances} instances` });
+    }
     return issues;
 }