@plitzi/sdk-schema 0.37.8 → 0.37.10

package/dist/helpers/schemaValidator.mjs

@@ -1,27 +1,37 @@
 import { isValidElementId as e } from "./elementId.mjs";
-import { findLayoutCycle as t } from "@plitzi/sdk-shared/schema/layoutChain";
+import { isInstance as t, propNameProblem as n } from "./components.mjs";
+import { findLayoutCycle as r } from "@plitzi/sdk-shared/schema/layoutChain";
 //#region src/helpers/schemaValidator.ts
-var n = /* @__PURE__ */ new Set([
+var i = /* @__PURE__ */ new Set([
 	"UNRESOLVED_BINDING_SOURCE",
 	"MISMATCHED_BINDING_SOURCE",
-	"UNRESOLVED_INTERACTION_TARGET"
-]), r = (e) => !n.has(e.code), i = (n) => {
-	let r = [], i = [], { flat: a, pages: o, pageFolders: s, variables: c } = n, l = (e) => !!a[e], u = (e) => a[e], d = () => Object.values(a).filter((e) => e?.definition?.type === "layoutContainer" && !e.definition.parentId).map((e) => e.id), f = () => [...o, ...d()], p = () => !a || typeof a != "object" ? (r.push({
+	"UNRESOLVED_INTERACTION_TARGET",
+	"UNRESOLVED_COMPONENT",
+	"UNKNOWN_COMPONENT_SLOT"
+]), a = (e) => !i.has(e.code), o = (i, a) => {
+	let s = [], c = [], { flat: l, pages: u, pageFolders: d, variables: f, components: p } = i, m = a?.baseElementId, h = (e) => !!l[e], g = (e) => l[e], _ = () => Object.values(l).filter((e) => e?.definition?.type === "layoutContainer" && !e.definition.parentId).map((e) => e.id), v = () => [.../* @__PURE__ */ new Set([
+		...u,
+		..._(),
+		...m ? [m] : []
+	])], y = () => !l || typeof l != "object" ? (s.push({
 		code: "INVALID_FLAT",
 		message: "Schema.flat must be a valid Record<string, Element>"
-	}), !1) : Array.isArray(o) ? Array.isArray(s) ? Array.isArray(c) ? !0 : (r.push({
+	}), !1) : Array.isArray(u) ? Array.isArray(d) ? Array.isArray(f) ? !p || typeof p != "object" ? (s.push({
+		code: "INVALID_COMPONENTS",
+		message: "Schema.components must be a Record<string, SpaceComponent>"
+	}), !1) : !0 : (s.push({
 		code: "INVALID_VARIABLES",
 		message: "Schema.variables must be an array"
-	}), !1) : (r.push({
+	}), !1) : (s.push({
 		code: "INVALID_PAGE_FOLDERS",
 		message: "Schema.pageFolders must be an array"
-	}), !1) : (r.push({
+	}), !1) : (s.push({
 		code: "INVALID_PAGES",
 		message: "Schema.pages must be an array of element IDs"
-	}), !1), m = () => {
-		Object.entries(a).forEach(([e, t]) => {
+	}), !1), b = () => {
+		Object.entries(l).forEach(([e, t]) => {
 			if (!t) {
-				r.push({
+				s.push({
 					code: "NULL_ELEMENT",
 					message: `Element with id "${e}" is null or undefined`,
 					elementId: e
@@ -29,47 +39,47 @@ var n = /* @__PURE__ */ new Set([
 				return;
 			}
 			if (!t.id) {
-				r.push({
+				s.push({
 					code: "MISSING_ID",
 					message: `Element at key "${e}" has no id property`
 				});
 				return;
 			}
-			if (t.id !== e && r.push({
+			if (t.id !== e && s.push({
 				code: "ID_MISMATCH",
 				message: `Element id "${t.id}" doesn't match flat key "${e}"`,
 				elementId: e
 			}), !t.definition) {
-				r.push({
+				s.push({
 					code: "MISSING_DEFINITION",
 					message: "Element missing definition",
 					elementId: e
 				});
 				return;
 			}
-			let { definition: n, attributes: a } = t;
-			n.type || r.push({
+			let { definition: n, attributes: r } = t;
+			n.type || s.push({
 				code: "MISSING_TYPE",
 				message: "Element missing definition.type",
 				elementId: e
-			}), n.label === void 0 && r.push({
+			}), n.label === void 0 && s.push({
 				code: "MISSING_LABEL",
 				message: "Element missing definition.label",
 				elementId: e
-			}), n.rootId || r.push({
+			}), n.rootId || s.push({
 				code: "MISSING_ROOT_ID",
 				message: "Element missing definition.rootId",
 				elementId: e
-			}), (!n.styleSelectors || typeof n.styleSelectors != "object") && r.push({
+			}), (!n.styleSelectors || typeof n.styleSelectors != "object") && s.push({
 				code: "MISSING_STYLE_SELECTORS",
 				message: "Element missing or invalid definition.styleSelectors",
 				elementId: e
-			}), a || i.push({
+			}), r || c.push({
 				code: "MISSING_ATTRIBUTES",
 				message: "Element has no attributes",
 				elementId: e
 			}), n.items && (Array.isArray(n.items) ? n.items.forEach((t, n) => {
-				l(t) || r.push({
+				h(t) || s.push({
 					code: "ORPHANED_ITEM_REFERENCE",
 					message: `Element "${e}" references non-existent child "${t}" at items[${n}]`,
 					elementId: e,
@@ -78,24 +88,24 @@ var n = /* @__PURE__ */ new Set([
 						index: n
 					}
 				});
-			}) : r.push({
+			}) : s.push({
 				code: "INVALID_ITEMS",
 				message: "Element.definition.items must be an array",
 				elementId: e
-			})), n.parentId && !l(n.parentId) && r.push({
+			})), n.parentId && !h(n.parentId) && s.push({
 				code: "ORPHANED_PARENT_REFERENCE",
 				message: `Element "${e}" has parentId "${n.parentId}" but parent doesn't exist in flat`,
 				elementId: e,
 				details: { parentId: n.parentId }
 			});
 		});
-	}, h = () => {
-		Object.values(a).forEach((e) => {
+	}, x = () => {
+		Object.values(l).forEach((e) => {
 			if (!e?.definition) return;
 			let { id: t, definition: n } = e;
 			if (n.items && n.items.forEach((e) => {
-				let n = u(e);
-				n?.definition && n.definition.parentId !== t && r.push({
+				let n = g(e);
+				n?.definition && n.definition.parentId !== t && s.push({
 					code: "PARENT_CHILD_MISMATCH",
 					message: `Element "${e}" is in "${t}".items but has parentId "${n.definition.parentId}"`,
 					elementId: e,
@@ -105,87 +115,87 @@ var n = /* @__PURE__ */ new Set([
 					}
 				});
 			}), n.parentId) {
-				let e = u(n.parentId);
+				let e = g(n.parentId);
 				if (!e?.definition) return;
-				let i = e.definition.items || [];
-				i.includes(t) || r.push({
+				let r = e.definition.items || [];
+				r.includes(t) || s.push({
 					code: "PARENT_CHILD_MISMATCH",
 					message: `Element "${t}" has parentId "${n.parentId}" but parent doesn't have it in items`,
 					elementId: t,
 					details: {
 						parentId: n.parentId,
-						parentItems: i
+						parentItems: r
 					}
 				});
 			}
 		});
-	}, g = () => {
-		let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), n = (i) => {
-			if (t.has(i)) return r.push({
+	}, S = () => {
+		let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), n = (r) => {
+			if (t.has(r)) return s.push({
 				code: "CIRCULAR_REFERENCE",
-				message: `Circular reference detected involving element "${i}"`,
-				elementId: i
+				message: `Circular reference detected involving element "${r}"`,
+				elementId: r
 			}), !0;
-			if (e.has(i)) return !1;
-			e.add(i), t.add(i);
-			let a = u(i);
-			if (a?.definition?.items) {
-				for (let e of a.definition.items) if (n(e)) return t.delete(i), !0;
+			if (e.has(r)) return !1;
+			e.add(r), t.add(r);
+			let i = g(r);
+			if (i?.definition?.items) {
+				for (let e of i.definition.items) if (n(e)) return t.delete(r), !0;
 			}
-			let o = /* @__PURE__ */ new Set(), s = a;
-			for (; s?.definition?.parentId;) {
-				if (o.has(s.id)) return r.push({
+			let a = /* @__PURE__ */ new Set(), o = i;
+			for (; o?.definition?.parentId;) {
+				if (a.has(o.id)) return s.push({
 					code: "CIRCULAR_PARENT_REFERENCE",
-					message: `Circular parent reference detected involving element "${s.id}"`,
-					elementId: s.id
+					message: `Circular parent reference detected involving element "${o.id}"`,
+					elementId: o.id
 				}), !0;
-				o.add(s.id), s = u(s.definition.parentId);
+				a.add(o.id), o = g(o.definition.parentId);
 			}
-			return t.delete(i), !1;
+			return t.delete(r), !1;
 		};
-		Object.keys(a).forEach((t) => {
+		Object.keys(l).forEach((t) => {
 			e.has(t) || n(t);
 		});
-	}, _ = () => {
+	}, C = () => {
 		let e = /* @__PURE__ */ new Set(), t = 0;
-		o.forEach((n, i) => {
-			e.has(n) && r.push({
+		u.forEach((n, r) => {
+			e.has(n) && s.push({
 				code: "DUPLICATE_PAGE",
-				message: `Duplicate page ID "${n}" in pages array at index ${i}`,
+				message: `Duplicate page ID "${n}" in pages array at index ${r}`,
 				elementId: n
 			}), e.add(n);
-			let a = u(n);
-			if (!a) {
-				r.push({
+			let i = g(n);
+			if (!i) {
+				s.push({
 					code: "INVALID_PAGE_REFERENCE",
 					message: `Page ID "${n}" in pages array doesn't exist in flat`,
 					elementId: n
 				});
 				return;
 			}
-			a.definition.type !== "page" && r.push({
+			i.definition.type !== "page" && s.push({
 				code: "INVALID_PAGE_TYPE",
-				message: `Element "${n}" in pages array has type "${a.definition.type}" instead of "page"`,
+				message: `Element "${n}" in pages array has type "${i.definition.type}" instead of "page"`,
 				elementId: n
-			}), a.definition.rootId !== n && r.push({
+			}), i.definition.rootId !== n && s.push({
 				code: "PAGE_ROOT_ID_MISMATCH",
-				message: `Page "${n}" has rootId "${a.definition.rootId}" instead of its own ID`,
+				message: `Page "${n}" has rootId "${i.definition.rootId}" instead of its own ID`,
 				elementId: n
-			}), a.attributes?.default && t++;
-		}), t === 0 && o.length > 0 ? i.push({
+			}), i.attributes?.default && t++;
+		}), t === 0 && u.length > 0 ? c.push({
 			code: "NO_DEFAULT_PAGE",
 			message: "No default page found in schema"
-		}) : t > 1 && i.push({
+		}) : t > 1 && c.push({
 			code: "MULTIPLE_DEFAULT_PAGES",
 			message: `Found ${t} default pages, expected 1`
 		});
-	}, v = () => {
-		f().forEach((e) => {
-			let t = u(e);
+	}, w = () => {
+		v().forEach((e) => {
+			let t = g(e);
 			if (!t) return;
-			let n = (t) => {
-				let i = u(t);
-				i?.definition && (i.definition.rootId !== e && r.push({
+			let n = /* @__PURE__ */ new Set([e]), r = (t) => {
+				let i = g(t);
+				i?.definition && !n.has(t) && (n.add(t), i.definition.rootId !== e && s.push({
 					code: "ROOT_ID_MISMATCH",
 					message: `Element "${t}" has rootId "${i.definition.rootId}" but should be "${e}" (its root's ID)`,
 					elementId: t,
@@ -193,124 +203,124 @@ var n = /* @__PURE__ */ new Set([
 						expectedRootId: e,
 						actualRootId: i.definition.rootId
 					}
-				}), i.definition.items && i.definition.items.forEach((e) => n(e)));
+				}), i.definition.items && i.definition.items.forEach((e) => r(e)));
 			};
-			t.definition.items && t.definition.items.forEach((e) => n(e));
+			t.definition.items && t.definition.items.forEach((e) => r(e));
 		});
-	}, y = () => {
+	}, T = () => {
 		let e = /* @__PURE__ */ new Set();
-		s.forEach((t, n) => {
+		d.forEach((t, n) => {
 			if (!t.id) {
-				r.push({
+				s.push({
 					code: "INVALID_FOLDER",
 					message: `Page folder at index ${n} has no id`
 				});
 				return;
 			}
-			e.has(t.id) && r.push({
+			e.has(t.id) && s.push({
 				code: "DUPLICATE_FOLDER",
 				message: `Duplicate folder ID "${t.id}"`,
 				elementId: t.id
-			}), e.add(t.id), t.parentId && (e.has(t.parentId) || r.push({
+			}), e.add(t.id), t.parentId && (e.has(t.parentId) || s.push({
 				code: "ORPHANED_FOLDER_PARENT",
 				message: `Folder "${t.id}" has non-existent parent "${t.parentId}"`,
 				elementId: t.id,
 				details: { parentId: t.parentId }
 			}));
 		});
-	}, b = () => {
+	}, E = () => {
 		let e = /* @__PURE__ */ new Set();
-		d().forEach((n) => {
-			let i = t(u, n);
-			i.length === 0 || e.has(i[0]) || (i.forEach((t) => e.add(t)), r.push({
+		_().forEach((t) => {
+			let n = r(g, t);
+			n.length === 0 || e.has(n[0]) || (n.forEach((t) => e.add(t)), s.push({
 				code: "LAYOUT_CYCLE",
-				message: `Layouts sit inside each other in a circle: ${i.join(" → ")}`,
-				elementId: n,
-				details: { cycle: i }
+				message: `Layouts sit inside each other in a circle: ${n.join(" → ")}`,
+				elementId: t,
+				details: { cycle: n }
 			}));
 		});
-	}, x = (e) => {
-		let t = /* @__PURE__ */ new Set(), n = (e) => {
-			if (t.has(e)) return;
-			t.add(e);
-			let r = u(e);
-			r?.definition?.items && r.definition.items.forEach((e) => n(e));
-		}, r = /* @__PURE__ */ new Set(), o = (e) => {
-			if (r.has(e)) return;
-			r.add(e), n(e);
-			let t = u(e)?.attributes;
-			t?.layout && o(t.layout), t?.layoutContainer && n(t.layoutContainer);
+	}, D = () => {
+		let e = /* @__PURE__ */ new Set(), t = (n) => {
+			if (e.has(n)) return;
+			e.add(n);
+			let r = g(n);
+			r?.definition?.items && r.definition.items.forEach((e) => t(e));
+		}, n = /* @__PURE__ */ new Set(), r = (e) => {
+			if (n.has(e)) return;
+			n.add(e), t(e);
+			let i = g(e)?.attributes;
+			i?.layout && r(i.layout), i?.layoutContainer && t(i.layoutContainer);
 		};
-		e ? o(e) : f().forEach(o);
-		let s = new Set(f());
-		Object.keys(a).forEach((e) => {
-			let n = u(e);
-			n && !t.has(e) && n.definition.type !== "page" && !s.has(e) && i.push({
+		m ? r(m) : v().forEach(r);
+		let i = new Set(v());
+		Object.keys(l).forEach((t) => {
+			let n = g(t);
+			n && !e.has(t) && n.definition.type !== "page" && !i.has(t) && c.push({
 				code: "ORPHANED_ELEMENT",
-				message: `Element "${e}" is not reachable from any page or layout`,
-				elementId: e
+				message: `Element "${t}" is not reachable from any page or layout`,
+				elementId: t
 			});
 		});
-	}, S = () => {
+	}, O = () => {
 		let e = /* @__PURE__ */ new Set();
-		c.forEach((t, n) => {
+		f.forEach((t, n) => {
 			if (!t.name) {
-				r.push({
+				s.push({
 					code: "INVALID_VARIABLE",
 					message: `Variable at index ${n} has no name`
 				});
 				return;
 			}
-			e.has(t.name) && r.push({
+			e.has(t.name) && s.push({
 				code: "DUPLICATE_VARIABLE",
 				message: `Duplicate variable name "${t.name}"`,
 				details: { variableName: t.name }
-			}), e.add(t.name), t.type || i.push({
+			}), e.add(t.name), t.type || c.push({
 				code: "MISSING_VARIABLE_TYPE",
 				message: `Variable "${t.name}" has no type`,
 				details: { variableName: t.name }
 			});
 		});
-	}, C = () => {
-		Object.values(a).forEach((t) => {
-			t && (e(t.id) || r.push({
+	}, k = () => {
+		Object.values(l).forEach((t) => {
+			t && (e(t.id) || s.push({
 				code: "INVALID_ELEMENT_ID",
 				message: `Element "${t.id}" has a name that must start with a letter, then letters, numbers, hyphens and underscores (no hyphen or underscore at the start, and no hyphen at the end)`,
 				elementId: t.id
 			}));
 		});
-	}, w = (e) => {
-		let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
-		Object.values(a).forEach((r) => {
-			if (!r) return;
-			t.add(r.id);
-			let a = e?.[r.definition.type];
-			a && i.set(r.id, a), n.add(r.definition.type);
-		}), Object.values(a).forEach((a) => {
-			a && a.definition.bindings && Object.entries(a.definition.bindings).forEach(([o, s]) => {
-				(s ?? []).forEach((s) => {
-					let c = s.source.split(".")[0], l = c.indexOf("_");
+	}, A = (e) => {
+		let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
+		Object.values(l).forEach((i) => {
+			if (!i) return;
+			t.add(i.id);
+			let a = e?.[i.definition.type];
+			a && r.set(i.id, a), n.add(i.definition.type);
+		}), Object.values(l).forEach((i) => {
+			i && i.definition.bindings && Object.entries(i.definition.bindings).forEach(([a, o]) => {
+				(o ?? []).forEach((o) => {
+					let c = o.source.split(".")[0], l = c.indexOf("_");
 					if (l === -1) return;
-					let u = c.slice(0, l), d = c.slice(l + 1), f = `Element "${a.id}" binds ${o}.${s.to} to "${s.source}"`;
+					let u = c.slice(0, l), d = c.slice(l + 1), f = `Element "${i.id}" binds ${a}.${o.to} to "${o.source}"`;
 					if (!t.has(d)) {
-						(e || n.has(u)) && r.push({
+						(e || n.has(u)) && s.push({
 							code: "UNRESOLVED_BINDING_SOURCE",
 							message: `${f}, but no element answers to the name "${d}"`,
-							elementId: a.id,
+							elementId: i.id,
 							details: {
-								source: s.source,
+								source: o.source,
 								elementId: d
 							}
 						});
 						return;
 					}
-					let p = i.get(d);
-					p && p !== u && r.push({
+					let p = r.get(d);
+					p && p !== u && s.push({
 						code: "MISMATCHED_BINDING_SOURCE",
 						message: `${f}, but "${d}" publishes its source as "${p}_${d}"`,
-						elementId: a.id,
+						elementId: i.id,
 						details: {
-							source: s.source,
+							source: o.source,
 							elementId: d,
 							expected: `${p}_${d}`
 						}
@@ -318,87 +328,190 @@ var n = /* @__PURE__ */ new Set([
 				});
 			});
 		});
-	}, T = () => {
-		let t = new Set(Object.keys(a));
-		Object.values(a).forEach((n) => {
-			let a = n?.definition.interactions;
-			if (!a) return;
-			let o = Object.keys(a);
-			Object.entries(a).forEach(([a, s]) => {
-				e(a) || r.push({
+	}, j = () => {
+		let t = new Set(Object.keys(l));
+		Object.values(l).forEach((n) => {
+			let r = n?.definition.interactions;
+			if (!r) return;
+			let i = Object.keys(r);
+			Object.entries(r).forEach(([r, a]) => {
+				e(r) || s.push({
 					code: "INVALID_INTERACTION_ID",
-					message: `Interaction "${a}" on element "${n.id}" has a name that must start with a letter, then letters, numbers, hyphens and underscores — a later step reads it as {{ ${a}.field }}`,
+					message: `Interaction "${r}" on element "${n.id}" has a name that must start with a letter, then letters, numbers, hyphens and underscores — a later step reads it as {{ ${r}.field }}`,
 					elementId: n.id
-				}), s.id !== a && r.push({
+				}), a.id !== r && s.push({
 					code: "INTERACTION_ID_MISMATCH",
-					message: `Interaction id "${s.id}" on element "${n.id}" doesn't match its key "${a}"`,
+					message: `Interaction id "${a.id}" on element "${n.id}" doesn't match its key "${r}"`,
 					elementId: n.id
 				}), ["beforeNode", "afterNode"].forEach((e) => {
-					let t = s[e];
-					t && !o.includes(t) && r.push({
+					let t = a[e];
+					t && !i.includes(t) && s.push({
 						code: "BROKEN_FLOW_LINK",
-						message: `Interaction "${s.id}" on element "${n.id}" names ${e} "${t}", which is not a node of this flow`,
+						message: `Interaction "${a.id}" on element "${n.id}" names ${e} "${t}", which is not a node of this flow`,
 						elementId: n.id
 					});
-				}), s.flowId && !o.includes(s.flowId) && r.push({
+				}), a.flowId && !i.includes(a.flowId) && s.push({
 					code: "BROKEN_FLOW_ID",
-					message: `Interaction "${s.id}" on element "${n.id}" belongs to flow "${s.flowId}", which is not a node of this flow`,
+					message: `Interaction "${a.id}" on element "${n.id}" belongs to flow "${a.flowId}", which is not a node of this flow`,
 					elementId: n.id
-				}), s.type === "callback" && s.elementId && !t.has(s.elementId) && r.push({
+				}), a.type === "callback" && a.elementId && !t.has(a.elementId) && s.push({
 					code: "UNRESOLVED_INTERACTION_TARGET",
-					message: `Interaction "${s.id}" on element "${n.id}" runs against "${s.elementId}", but no element answers to that name`,
+					message: `Interaction "${a.id}" on element "${n.id}" runs against "${a.elementId}", but no element answers to that name`,
 					elementId: n.id
 				});
-				let c = s.type === "trigger" && s.action === "onSubmit" && s.enabled ? u(s.elementId ?? n.id) : void 0;
-				c?.definition.type === "form" && c.attributes.managedByInteractions !== !0 && i.push({
+				let o = a.type === "trigger" && a.action === "onSubmit" && a.enabled ? g(a.elementId ?? n.id) : void 0;
+				o?.definition.type === "form" && o.attributes.managedByInteractions !== !0 && c.push({
 					code: "FORM_SUBMIT_UNMANAGED",
-					message: `Form "${c.id}" has an onSubmit flow but is not managedByInteractions, so the browser submits it natively and the flow never runs — set managedByInteractions: true`,
-					elementId: c.id
+					message: `Form "${o.id}" has an onSubmit flow but is not managedByInteractions, so the browser submits it natively and the flow never runs — set managedByInteractions: true`,
+					elementId: o.id
 				});
 			});
 		});
-	}, E = () => {
-		Object.values(a).forEach((e) => {
+	}, M = () => {
+		Object.values(l).forEach((e) => {
 			if (!e || !e.definition.bindings) return;
 			let t = /* @__PURE__ */ new Set();
-			Object.entries(e.definition.bindings).forEach(([n, i]) => {
-				(i ?? []).forEach((i) => {
-					if (!i.id) {
-						r.push({
+			Object.entries(e.definition.bindings).forEach(([n, r]) => {
+				(r ?? []).forEach((r) => {
+					if (!r.id) {
+						s.push({
 							code: "MISSING_BINDING_ID",
-							message: `Element "${e.id}" has a ${n} binding to "${i.to}" with no id`,
+							message: `Element "${e.id}" has a ${n} binding to "${r.to}" with no id`,
 							elementId: e.id
 						});
 						return;
 					}
-					t.has(i.id) && r.push({
+					t.has(r.id) && s.push({
 						code: "DUPLICATE_BINDING_ID",
-						message: `Element "${e.id}" has two bindings called "${i.id}"`,
+						message: `Element "${e.id}" has two bindings called "${r.id}"`,
 						elementId: e.id,
-						details: { bindingId: i.id }
-					}), t.add(i.id);
+						details: { bindingId: r.id }
+					}), t.add(r.id);
 				});
 			});
 		});
-	};
-	return { validate: (e) => {
-		let { baseElementId: t } = e ?? {};
-		return p() ? (m(), h(), g(), _(), v(), y(), b(), x(t), S(), C(), w(e?.sourceTypes), E(), T(), {
-			valid: r.length === 0,
-			errors: r,
-			warnings: i
-		}) : {
-			valid: !1,
-			errors: r,
-			warnings: i
+	}, N = () => {
+		let r = new Map(Object.keys(l).map((e) => [e, ""])), u = (e) => e ? `component "${e}"` : "the pages", d = /* @__PURE__ */ new Map();
+		Object.entries(p).forEach(([t, l]) => {
+			let d = `Component "${t}"`;
+			l.id !== t && s.push({
+				code: "COMPONENT_ID_MISMATCH",
+				message: `${d} has id "${l.id}"`,
+				componentId: t
+			}), e(t) || s.push({
+				code: "INVALID_COMPONENT_ID",
+				message: `${d} has a name that must start with a letter, then letters, numbers, hyphens and underscores`,
+				componentId: t
+			});
+			let f = l.flat[l.rootId];
+			if (!f) {
+				s.push({
+					code: "COMPONENT_ROOT_MISSING",
+					message: `${d} is rooted at "${l.rootId}", which is not an element of its tree`,
+					componentId: t
+				});
+				return;
+			}
+			f.definition.parentId && s.push({
+				code: "COMPONENT_ROOT_HAS_PARENT",
+				message: `${d} is rooted at "${l.rootId}", which names a parent — a component's root has none`,
+				elementId: l.rootId,
+				componentId: t
+			}), Object.keys(l.flat).forEach((e) => {
+				let n = r.get(e);
+				n === void 0 ? r.set(e, t) : s.push({
+					code: "DUPLICATE_ELEMENT_ID",
+					message: `"${e}" names an element of ${u(n)} and one of ${u(t)} — an id is one element in the whole space`,
+					elementId: e,
+					componentId: t
+				});
+			}), Object.keys(l.props ?? {}).forEach((e) => {
+				let r = n(e);
+				r && s.push({
+					code: "INVALID_COMPONENT_PROP",
+					message: `${d}: ${r}`,
+					componentId: t
+				});
+			}), (l.slots ?? []).forEach((e) => {
+				Object.hasOwn(l.flat, e) || s.push({
+					code: "MISSING_COMPONENT_SLOT",
+					message: `${d} declares slot "${e}", which is not an element of its tree`,
+					componentId: t
+				});
+			});
+			let p = o({
+				...i,
+				flat: l.flat,
+				pages: [],
+				pageFolders: [],
+				components: {}
+			}, {
+				baseElementId: l.rootId,
+				sourceTypes: a?.sourceTypes
+			}).validate();
+			p.errors.forEach((e) => s.push({
+				...e,
+				message: `${d}: ${e.message}`,
+				componentId: t
+			})), p.warnings.forEach((e) => c.push({
+				...e,
+				message: `${d}: ${e.message}`,
+				componentId: t
+			}));
+		}), [["", l], ...Object.entries(p).map(([e, t]) => [e, t.flat])].forEach(([e, n]) => {
+			Object.values(n).forEach((r) => {
+				if (!r || !t(r)) return;
+				let i = r.attributes.referenceId, a = typeof i == "string" ? p[i] : void 0;
+				if (!a || typeof i != "string") {
+					s.push({
+						code: "UNRESOLVED_COMPONENT",
+						message: `Instance "${r.id}" places component "${String(i)}", which this space does not declare`,
+						elementId: r.id,
+						...e ? { componentId: e } : {}
+					});
+					return;
+				}
+				e && d.set(e, (d.get(e) ?? /* @__PURE__ */ new Set()).add(i)), (r.definition.items ?? []).forEach((t) => {
+					let o = n[t]?.attributes.slot ?? a.slots?.[0];
+					(typeof o != "string" || !a.slots?.includes(o)) && s.push({
+						code: "UNKNOWN_COMPONENT_SLOT",
+						message: `"${t}" fills ${typeof o == "string" ? `slot "${o}"` : "a slot"} of instance "${r.id}", but component "${i}" declares ${a.slots?.length ? `only ${a.slots.map((e) => `"${e}"`).join(", ")}` : "no slots"}`,
+						elementId: t,
+						...e ? { componentId: e } : {}
+					});
+				});
+			});
+		});
+		let f = /* @__PURE__ */ new Set(), m = (e, t) => {
+			if (t.includes(e)) {
+				let n = [...t.slice(t.indexOf(e)), e];
+				n.some((e) => f.has(e)) || (n.forEach((e) => f.add(e)), s.push({
+					code: "COMPONENT_CYCLE",
+					message: `Components place each other in a circle: ${n.join(" → ")}`,
+					componentId: e,
+					details: { cycle: n }
+				}));
+				return;
+			}
+			d.get(e)?.forEach((n) => m(n, [...t, e]));
 		};
+		Object.keys(p).forEach((e) => m(e, []));
+	};
+	return { validate: () => y() ? (b(), x(), S(), C(), w(), T(), E(), D(), O(), k(), A(a?.sourceTypes), M(), j(), m || N(), {
+		valid: s.length === 0,
+		errors: s,
+		warnings: c
+	}) : {
+		valid: !1,
+		errors: s,
+		warnings: c
 	} };
-}, a = (e, t) => i(e).validate(t), o = (e, t, n) => {
-	let r = a(e, t);
+}, s = (e, t) => o(e, t).validate(), c = (e, t, n) => {
+	let r = s(e, t);
 	if (!r.valid) {
 		let e = `Invalid schema${n ? ` (${n})` : ""}: ${r.errors.map((e) => e.message).join("; ")}`;
 		throw Error(e);
 	}
-}, s = (e, t) => a(e, t).valid;
+}, l = (e, t) => s(e, t).valid;
 //#endregion
-export { n as REFERENCE_ERROR_CODES, o as assertSchemaValid, r as isIntegrityError, s as isSchemaValid, a as validateSchema };
+export { i as REFERENCE_ERROR_CODES, c as assertSchemaValid, a as isIntegrityError, l as isSchemaValid, s as validateSchema };