@shapio/schema 0.5.7 → 0.5.9

package/dist/index.js

@@ -224,6 +224,11 @@ const ModelDefinitionInputSchema = Type.Object({
 	localized: Type.Optional(Type.Boolean()),
 	/** Entries have separate draft and published states. Default true. */
 	draftAndPublish: Type.Optional(Type.Boolean()),
+	/**
+	* Collections only: the stable ID of the collection this one extends (its parent). The model inherits
+	* the parent's fields, locked, and adds its own (plan polymorphic-types).
+	*/
+	extends: Type.Optional(Type.String()),
 	display: Type.Optional(ModelDisplayInputSchema)
 }, closed$3);
 const ComponentDefinitionInputSchema = Type.Object({
@@ -828,159 +833,148 @@ const suggestPlural = (apiKey) => {
 	return `${apiKey.slice(0, 59)}${PLURAL_FALLBACK_SUFFIX}`;
 };
 //#endregion
-//#region src/normalize.ts
-const SETTINGS_DEFAULTS = {
-	code: { language: "plain" },
-	richtext: { formatVersion: 1 },
-	enum: { multiple: false },
-	media: { multiple: false },
-	component: { repeatable: false }
-};
-/** Optional text properties where an empty string means "not set". */
-const OPTIONAL_TEXT_KEYS = /* @__PURE__ */ new Set([
-	"description",
-	"category",
-	"icon",
-	"titleFieldId",
-	"coverFieldId",
-	"pluralApiKey"
-]);
-/** Optional list properties where an empty list means "not set". `fields` is never optional. */
-const OPTIONAL_LIST_KEYS = /* @__PURE__ */ new Set([
-	"listFieldIds",
-	"groups",
-	"canvasFieldIds",
-	"stripFieldIds"
-]);
-const withoutEmpty = (value) => {
-	const result = {};
-	for (const [key, entry] of Object.entries(value)) {
-		const isEmptyText = OPTIONAL_TEXT_KEYS.has(key) && entry === "";
-		const isEmptyList = OPTIONAL_LIST_KEYS.has(key) && Array.isArray(entry) && entry.length === 0;
-		if (entry === void 0 || isEmptyText || isEmptyList) continue;
-		result[key] = entry;
+//#region src/inheritance/resolve.ts
+/**
+* Model inheritance (plan polymorphic-types). A collection may extend another (`extends`, the parent's stable
+* ID). Stored definitions hold their own fields only; the effective definition is resolved at read time:
+* every ancestor's fields (root first, each marked `inheritedFrom`), then the model's own, and the display
+* merged down the chain. Nothing is copied into children, so a parent edit changes one definition.
+*/
+/** Most levels a family may have, root included (`Products > Physical > Apparel` is three). */
+const MAX_INHERITANCE_DEPTH = 8;
+/** A definition that may be a parent: a collection. */
+const canBeParent = (definition) => definition !== void 0 && definition.kind === "collection";
+/**
+* The ancestors of a definition, root first, walking `extends` up. Stops at the first problem (missing,
+* invalid or cyclic parent, or more than MAX_INHERITANCE_DEPTH levels) and returns what resolved so far.
+*/
+const ancestorChain = (definition, lookup) => {
+	const upward = [];
+	const seen = /* @__PURE__ */ new Set([definition.id]);
+	let current = definition;
+	while (isModelDefinition(current) && current.extends !== void 0) {
+		const parentId = current.extends;
+		const at = current.id;
+		const stop = (problem) => ({
+			ids: upward.reverse(),
+			problem,
+			problemAt: at
+		});
+		if (parentId === current.id) return stop("invalid");
+		if (seen.has(parentId)) return stop("cycle");
+		const parent = lookup(parentId);
+		if (!parent) return stop("missing");
+		if (!canBeParent(parent)) return stop("invalid");
+		if (upward.length + 1 >= 8) return stop("tooDeep");
+		upward.push(parentId);
+		seen.add(parentId);
+		current = parent;
 	}
-	return result;
-};
-const normalizeField = (field) => {
-	const normalized = {
-		id: field.id,
-		apiKey: field.apiKey,
-		label: field.label,
-		description: field.description,
-		type: field.type,
-		required: field.required ?? false,
-		localized: field.localized ?? false,
-		public: field.public ?? true,
-		unique: field.unique ?? false,
-		filterable: field.filterable ?? false,
-		sortable: field.sortable ?? false,
-		deprecated: field.deprecated ?? false,
-		defaultValue: field.defaultValue,
-		settings: {
-			...SETTINGS_DEFAULTS[field.type],
-			...field.settings
-		},
-		editor: {
-			id: field.editor?.id ?? DEFAULT_EDITORS[field.type],
-			options: field.editor?.options ?? {}
-		},
-		width: field.width === "full" ? void 0 : field.width
-	};
-	return withoutEmpty(normalized);
-};
-const normalizeModelDisplay = (display) => withoutEmpty({
-	...display,
-	layout: display?.layout === "document" ? void 0 : display?.layout
-});
-const normalizeComponentDisplay = (display) => withoutEmpty({ ...display });
+	return { ids: upward.reverse() };
+};
+/** Fields a model sees from one ancestor: its own fields, marked with the ancestor's ID. */
+const inheritedFieldsOf = (ancestor) => ancestor.fields.map((field) => ({
+	...field,
+	inheritedFrom: ancestor.id
+}));
+/** IDs of the fields in `fields` that `pick` keeps, in field order. */
+const fieldIdsWhere = (fields, pick) => fields.filter(pick).map((field) => field.id);
 /**
-* Applies defaults so that two definitions meaning the same thing are byte-identical once serialized
-* canonically: a hand-written file that omits `public` hashes the same as one that says `public: true`.
-* Empty optional strings and arrays are dropped, and so are the defaults of keys added after definitions
-* were first hashed (`width: 'full'`, `display.layout: 'document'`). A collection without a plural API ID
-* gets the suggested one (`suggestPlural`), so files and definitions from before plural API IDs keep working.
+* A child's display over its parent's (already merged) one. Scalars and `listFieldIds` take the child's value
+* when set, else the parent's. Groups are the parent's, then the child's. Canvas and strip take the child's
+* list when set; else the parent's list (when set) with the child's own fields appended where the automatic
+* rule would put them: canvas-eligible fields to the canvas, the other fields (not the cover) to the strip.
 */
-const normalizeDefinition = (input) => {
-	const fields = input.fields.map(normalizeField);
-	if (input.kind === "component") return withoutEmpty({
-		id: input.id,
-		kind: "component",
-		apiKey: input.apiKey,
-		label: input.label,
-		description: input.description,
-		category: input.category,
-		icon: input.icon,
-		fields,
-		display: normalizeComponentDisplay(input.display)
-	});
-	return withoutEmpty({
-		id: input.id,
-		kind: input.kind,
-		apiKey: input.apiKey,
-		pluralApiKey: input.kind === "collection" ? input.pluralApiKey || suggestPlural(input.apiKey) : void 0,
-		label: input.label,
-		description: input.description,
-		localized: input.localized ?? false,
-		draftAndPublish: input.draftAndPublish ?? true,
-		fields,
-		display: normalizeModelDisplay(input.display)
-	});
+const mergeDisplay = (parent, child, ownFields) => {
+	const merged = {};
+	const layout = child.layout ?? parent.layout;
+	const titleFieldId = child.titleFieldId ?? parent.titleFieldId;
+	const listFieldIds = child.listFieldIds ?? parent.listFieldIds;
+	const defaultSort = child.defaultSort ?? parent.defaultSort;
+	const coverFieldId = child.coverFieldId ?? parent.coverFieldId;
+	const groups = [...parent.groups ?? [], ...child.groups ?? []];
+	const ownCanvas = fieldIdsWhere(ownFields, isCanvasEligible);
+	const canvasFieldIds = child.canvasFieldIds ?? (parent.canvasFieldIds ? [...parent.canvasFieldIds, ...ownCanvas] : void 0);
+	const canvas = new Set(canvasFieldIds ?? []);
+	const stripFieldIds = child.stripFieldIds ?? (parent.stripFieldIds ? [...parent.stripFieldIds, ...fieldIdsWhere(ownFields, (field) => !isCanvasEligible(field) && !canvas.has(field.id) && field.id !== coverFieldId)] : void 0);
+	if (layout !== void 0) merged.layout = layout;
+	if (titleFieldId !== void 0) merged.titleFieldId = titleFieldId;
+	if (listFieldIds !== void 0) merged.listFieldIds = listFieldIds;
+	if (defaultSort !== void 0) merged.defaultSort = defaultSort;
+	if (groups.length > 0) merged.groups = groups;
+	if (canvasFieldIds !== void 0) merged.canvasFieldIds = canvasFieldIds;
+	if (coverFieldId !== void 0) merged.coverFieldId = coverFieldId;
+	if (stripFieldIds !== void 0) merged.stripFieldIds = stripFieldIds;
+	return merged;
 };
-/** Normalizes a definition that is already normalized-shaped (e.g. read back from the database). */
-const renormalizeDefinition = (definition) => normalizeDefinition(definition);
-//#endregion
-//#region src/validators/defaultValue.ts
 /**
-* Checks that a field's `defaultValue` has the right JSON shape for its type. Full content rules
-* (lengths, ranges) are applied by the content validator when the default is used.
-* Returns a message, or null when the default is acceptable.
+* The effective definition of a model: ancestors' fields first (root first, `inheritedFrom` set, otherwise the
+* same field objects' values and IDs), then its own fields; display merged root → model. A broken chain
+* (see `ancestorChain`) resolves over the part that resolved; the validator reports the problem.
 */
-const checkDefaultValue = (field) => {
-	const value = field.defaultValue;
-	if (value === void 0) return null;
-	const isString = typeof value === "string";
-	const matches = (pattern) => isString && pattern.test(value);
-	switch (field.type) {
-		case "string":
-		case "text":
-		case "code":
-		case "email":
-		case "url": return isString ? null : "must be a string";
-		case "slug": return matches(SLUG_PATTERN) ? null : "must be a lower-case slug";
-		case "uid": return matches(UID_PATTERN) ? null : "must contain only URL-safe characters";
-		case "number": return typeof value === "number" && Number.isFinite(value) ? null : "must be a number";
-		case "integer": return Number.isSafeInteger(value) ? null : "must be an integer";
-		case "decimal": return matches(DECIMAL_PATTERN) ? null : "must be a decimal string, e.g. \"12.50\"";
-		case "biginteger": return matches(BIGINTEGER_PATTERN) ? null : "must be an integer string, e.g. \"9007199254740993\"";
-		case "boolean": return typeof value === "boolean" ? null : "must be true or false";
-		case "date": return matches(DATE_PATTERN) ? null : "must be a date, YYYY-MM-DD";
-		case "datetime": return matches(DATETIME_PATTERN) ? null : "must be a UTC date-time, YYYY-MM-DDTHH:mm:ssZ";
-		case "time": return matches(TIME_PATTERN) ? null : "must be a time, HH:mm[:ss]";
-		case "enum": {
-			const allowed = new Set(field.settings.values.map((entry) => entry.value));
-			if (field.settings.multiple) return Array.isArray(value) && value.every((item) => typeof item === "string" && allowed.has(item)) ? null : "must be a list of the enum values";
-			return isString && allowed.has(value) ? null : "must be one of the enum values";
-		}
-		case "json": return null;
-		default: return `${field.type} fields cannot have a default value`;
+const resolveModelDefinition = (definition, lookup) => {
+	const { ids } = ancestorChain(definition, lookup);
+	const ancestors = ids.map((id) => lookup(id));
+	let display;
+	const fields = [];
+	for (const ancestor of ancestors) {
+		display = display === void 0 ? ancestor.display : mergeDisplay(display, ancestor.display, ancestor.fields);
+		fields.push(...inheritedFieldsOf(ancestor));
 	}
+	return {
+		...definition,
+		fields: [...fields, ...definition.fields],
+		display: display === void 0 ? definition.display : mergeDisplay(display, definition.display, definition.fields),
+		ancestorIds: ids
+	};
 };
-//#endregion
-//#region src/validators/issues.ts
-var SchemaValidationError = class extends Error {
-	issues;
-	constructor(issues) {
-		super(`Schema definition is invalid: ${issues.map((issue) => `${issue.path} ${issue.message}`).join("; ")}`);
-		this.name = "SchemaValidationError";
-		this.issues = issues;
-	}
+/** The fields a resolved model declares itself (not inherited). */
+const ownFields = (resolved) => resolved.fields.filter((field) => field.inheritedFrom === void 0);
+/** Definitions whose parent is `id`, in the given order. */
+const findChildDefinitions = (definitions, id) => definitions.filter((definition) => isModelDefinition(definition) && definition.extends === id && definition.id !== id);
+const memo = (compute) => {
+	const cache = /* @__PURE__ */ new Map();
+	return (id) => {
+		if (!cache.has(id)) cache.set(id, compute(id));
+		return cache.get(id);
+	};
+};
+const createDefinitionIndex = (definitions) => {
+	const byId = new Map(definitions.map((definition) => [definition.id, definition]));
+	const lookup = (id) => byId.get(id);
+	const children = /* @__PURE__ */ new Map();
+	for (const definition of definitions) if (isModelDefinition(definition) && definition.extends !== void 0 && definition.extends !== definition.id) children.set(definition.extends, [...children.get(definition.extends) ?? [], definition.id]);
+	const ancestors = memo((id) => {
+		const definition = byId.get(id);
+		return definition ? ancestorChain(definition, lookup).ids : [];
+	});
+	const childrenOf = (id) => children.get(id) ?? [];
+	const descendants = memo((id) => {
+		const found = [];
+		const seen = /* @__PURE__ */ new Set([id]);
+		const walk = (current) => {
+			for (const child of childrenOf(current)) if (!seen.has(child)) {
+				seen.add(child);
+				found.push(child);
+				walk(child);
+			}
+		};
+		walk(id);
+		return found;
+	});
+	return {
+		get: lookup,
+		resolve: memo((id) => {
+			const definition = byId.get(id);
+			return definition && isModelDefinition(definition) ? resolveModelDefinition(definition, lookup) : void 0;
+		}),
+		ancestors,
+		childrenOf,
+		descendants,
+		family: memo((id) => [id, ...descendants(id)]),
+		rootOf: (id) => ancestors(id)[0] ?? id
+	};
 };
-const issue = (path, code, message) => ({
-	path,
-	code,
-	message
-});
 //#endregion
 //#region src/validators/naming.ts
 /**
@@ -1000,6 +994,11 @@ const MODEL_TYPE_SUFFIXES = [
 	"Sort"
 ];
 const COMPONENT_TYPE_SUFFIXES = ["", "Input"];
+/**
+* Suffix of the GraphQL interface a model with children gets (`ProductInterface`, plan polymorphic-types).
+* Claimed only by models that have children, so existing schemas keep validating.
+*/
+const INTERFACE_TYPE_SUFFIX = "Interface";
 const MUTATION_PREFIXES = [
 	"create",
 	"update",
@@ -1124,11 +1123,15 @@ const RESERVED_QUERY_NAMES = [
 	"_snapshot",
 	"_site"
 ];
-/** Every name a definition contributes to the GraphQL schema. */
-const generatedNames = (definition) => {
+/**
+* Every name a definition contributes to the GraphQL schema. Fields are its own: a model that extends another
+* reuses the enum and zone types of inherited fields, which belong to the declaring model. `hasChildren` adds
+* the interface name of a model other models extend.
+*/
+const generatedNames = (definition, options = {}) => {
 	const typeName = toTypeName(definition.apiKey);
 	const definitionId = definition.id;
-	const names = (definition.kind === "component" ? COMPONENT_TYPE_SUFFIXES : MODEL_TYPE_SUFFIXES).map((suffix) => ({
+	const names = [...definition.kind === "component" ? COMPONENT_TYPE_SUFFIXES : MODEL_TYPE_SUFFIXES, ...options.hasChildren && definition.kind !== "component" ? [INTERFACE_TYPE_SUFFIX] : []].map((suffix) => ({
 		namespace: "type",
 		name: `${typeName}${suffix}`,
 		definitionId
@@ -1177,6 +1180,198 @@ const generatedNames = (definition) => {
 	return names;
 };
 //#endregion
+//#region src/naming/routePath.ts
+/**
+* Nested delivery paths (plan polymorphic-types). A model that extends another is addressed under its
+* ancestors: `/api/content/products/digital` is the route key `products/digital`, the ancestors' route keys
+* (`routeKeyOf`) and its own, joined by `/`. `routeKeyOf` alone stays the plural API ID that GraphQL names
+* and the API ID namespace use.
+*/
+const SEGMENT = API_KEY_PATTERN.source.slice(1, -1);
+/** A route key: one to MAX_INHERITANCE_DEPTH API IDs joined by `/` (`products/digital`). */
+const ROUTE_KEY_PATTERN = new RegExp(`^${SEGMENT}(?:/${SEGMENT}){0,7}$`);
+/** Longest route key: every level at the longest API ID, plus the separators. */
+const MAX_ROUTE_KEY_LENGTH = 520;
+/** The route key of a model under its ancestors (root first): `products/digital`. A root's is `routeKeyOf`. */
+const routePathOf = (definition, ancestors) => [...ancestors, definition].map(routeKeyOf).join("/");
+/**
+* Splits the path segments after a content prefix (`/api/content/`) into the route key and the rest: the
+* leading segments that are API IDs (at most MAX_INHERITANCE_DEPTH) form the key; the first one that is not
+* (an entry ID is a UUID, which always has a hyphen) starts the rest. A single segment that already holds a
+* whole route key (`products%2Fdigital`, decoded) is taken as it is. Undefined when no segment is a key.
+* Purely syntactic: shared by the server's URL rewrite and the in-process delivery matcher.
+*/
+const splitRoutePath = (segments) => {
+	const [first] = segments;
+	if (first === void 0) return;
+	if (!API_KEY_PATTERN.test(first)) return ROUTE_KEY_PATTERN.test(first) ? {
+		routeKey: first,
+		rest: segments.slice(1)
+	} : void 0;
+	let count = 1;
+	while (count < segments.length && count < 8 && API_KEY_PATTERN.test(segments[count])) count += 1;
+	return {
+		routeKey: segments.slice(0, count).join("/"),
+		rest: segments.slice(count)
+	};
+};
+//#endregion
+//#region src/normalize.ts
+const SETTINGS_DEFAULTS = {
+	code: { language: "plain" },
+	richtext: { formatVersion: 1 },
+	enum: { multiple: false },
+	media: { multiple: false },
+	component: { repeatable: false }
+};
+/** Optional text properties where an empty string means "not set". */
+const OPTIONAL_TEXT_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"category",
+	"icon",
+	"titleFieldId",
+	"coverFieldId",
+	"pluralApiKey",
+	"extends"
+]);
+/** Optional list properties where an empty list means "not set". `fields` is never optional. */
+const OPTIONAL_LIST_KEYS = /* @__PURE__ */ new Set([
+	"listFieldIds",
+	"groups",
+	"canvasFieldIds",
+	"stripFieldIds"
+]);
+const withoutEmpty = (value) => {
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) {
+		const isEmptyText = OPTIONAL_TEXT_KEYS.has(key) && entry === "";
+		const isEmptyList = OPTIONAL_LIST_KEYS.has(key) && Array.isArray(entry) && entry.length === 0;
+		if (entry === void 0 || isEmptyText || isEmptyList) continue;
+		result[key] = entry;
+	}
+	return result;
+};
+const normalizeField = (field) => {
+	const normalized = {
+		id: field.id,
+		apiKey: field.apiKey,
+		label: field.label,
+		description: field.description,
+		type: field.type,
+		required: field.required ?? false,
+		localized: field.localized ?? false,
+		public: field.public ?? true,
+		unique: field.unique ?? false,
+		filterable: field.filterable ?? false,
+		sortable: field.sortable ?? false,
+		deprecated: field.deprecated ?? false,
+		defaultValue: field.defaultValue,
+		settings: {
+			...SETTINGS_DEFAULTS[field.type],
+			...field.settings
+		},
+		editor: {
+			id: field.editor?.id ?? DEFAULT_EDITORS[field.type],
+			options: field.editor?.options ?? {}
+		},
+		width: field.width === "full" ? void 0 : field.width
+	};
+	return withoutEmpty(normalized);
+};
+const normalizeModelDisplay = (display) => withoutEmpty({
+	...display,
+	layout: display?.layout === "document" ? void 0 : display?.layout
+});
+const normalizeComponentDisplay = (display) => withoutEmpty({ ...display });
+/**
+* Applies defaults so that two definitions meaning the same thing are byte-identical once serialized
+* canonically: a hand-written file that omits `public` hashes the same as one that says `public: true`.
+* Empty optional strings and arrays are dropped, and so are the defaults of keys added after definitions
+* were first hashed (`width: 'full'`, `display.layout: 'document'`). A collection without a plural API ID
+* gets the suggested one (`suggestPlural`), so files and definitions from before plural API IDs keep working.
+*/
+const normalizeDefinition = (input) => {
+	const fields = input.fields.map(normalizeField);
+	if (input.kind === "component") return withoutEmpty({
+		id: input.id,
+		kind: "component",
+		apiKey: input.apiKey,
+		label: input.label,
+		description: input.description,
+		category: input.category,
+		icon: input.icon,
+		fields,
+		display: normalizeComponentDisplay(input.display)
+	});
+	return withoutEmpty({
+		id: input.id,
+		kind: input.kind,
+		apiKey: input.apiKey,
+		pluralApiKey: input.kind === "collection" ? input.pluralApiKey || suggestPlural(input.apiKey) : void 0,
+		label: input.label,
+		description: input.description,
+		localized: input.localized ?? false,
+		draftAndPublish: input.draftAndPublish ?? true,
+		extends: input.extends,
+		fields,
+		display: normalizeModelDisplay(input.display)
+	});
+};
+/** Normalizes a definition that is already normalized-shaped (e.g. read back from the database). */
+const renormalizeDefinition = (definition) => normalizeDefinition(definition);
+//#endregion
+//#region src/validators/defaultValue.ts
+/**
+* Checks that a field's `defaultValue` has the right JSON shape for its type. Full content rules
+* (lengths, ranges) are applied by the content validator when the default is used.
+* Returns a message, or null when the default is acceptable.
+*/
+const checkDefaultValue = (field) => {
+	const value = field.defaultValue;
+	if (value === void 0) return null;
+	const isString = typeof value === "string";
+	const matches = (pattern) => isString && pattern.test(value);
+	switch (field.type) {
+		case "string":
+		case "text":
+		case "code":
+		case "email":
+		case "url": return isString ? null : "must be a string";
+		case "slug": return matches(SLUG_PATTERN) ? null : "must be a lower-case slug";
+		case "uid": return matches(UID_PATTERN) ? null : "must contain only URL-safe characters";
+		case "number": return typeof value === "number" && Number.isFinite(value) ? null : "must be a number";
+		case "integer": return Number.isSafeInteger(value) ? null : "must be an integer";
+		case "decimal": return matches(DECIMAL_PATTERN) ? null : "must be a decimal string, e.g. \"12.50\"";
+		case "biginteger": return matches(BIGINTEGER_PATTERN) ? null : "must be an integer string, e.g. \"9007199254740993\"";
+		case "boolean": return typeof value === "boolean" ? null : "must be true or false";
+		case "date": return matches(DATE_PATTERN) ? null : "must be a date, YYYY-MM-DD";
+		case "datetime": return matches(DATETIME_PATTERN) ? null : "must be a UTC date-time, YYYY-MM-DDTHH:mm:ssZ";
+		case "time": return matches(TIME_PATTERN) ? null : "must be a time, HH:mm[:ss]";
+		case "enum": {
+			const allowed = new Set(field.settings.values.map((entry) => entry.value));
+			if (field.settings.multiple) return Array.isArray(value) && value.every((item) => typeof item === "string" && allowed.has(item)) ? null : "must be a list of the enum values";
+			return isString && allowed.has(value) ? null : "must be one of the enum values";
+		}
+		case "json": return null;
+		default: return `${field.type} fields cannot have a default value`;
+	}
+};
+//#endregion
+//#region src/validators/issues.ts
+var SchemaValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(`Schema definition is invalid: ${issues.map((issue) => `${issue.path} ${issue.message}`).join("; ")}`);
+		this.name = "SchemaValidationError";
+		this.issues = issues;
+	}
+};
+const issue = (path, code, message) => ({
+	path,
+	code,
+	message
+});
+//#endregion
 //#region src/validators/text.ts
 /**
 * Text no database can store as is: PostgreSQL `text` and `jsonb` reject U+0000, and `jsonb` rejects an
@@ -1451,6 +1646,10 @@ const checkDocumentLayout = (model, fields) => {
 	}));
 	return issues;
 };
+/**
+* The display's references to fields. Also run by the inheritance check on a child's resolved definition,
+* whose display may name inherited fields.
+*/
 const checkDisplay = (definition) => {
 	const fields = new Map(definition.fields.map((field) => [field.id, field]));
 	const fieldIds = new Set(fields.keys());
@@ -1499,10 +1698,94 @@ const validateDefinition = (definition) => {
 	if (!syntax) issues.push(...checkPluralApiKey(definition));
 	definition.fields.forEach((field, index) => issues.push(...checkField(field, index, definition)));
 	issues.push(...checkFieldUniqueness(definition));
-	issues.push(...checkDisplay(definition));
+	if (definition.kind === "component" || definition.extends === void 0) issues.push(...checkDisplay(definition));
 	return issues;
 };
 //#endregion
+//#region src/validators/inheritance.ts
+/**
+* Cross-definition checks of model inheritance (plan polymorphic-types): the parent exists and is a
+* collection, no cycles, at most MAX_INHERITANCE_DEPTH levels, a child's flags equal its parent's, its own
+* fields' API IDs differ from every inherited one, and its display is valid against its resolved fields.
+* Issues are reported on the definition that has to change, on its own paths.
+*/
+const withDefinition$1 = (definition, found) => ({
+	...found,
+	definitionId: definition.id
+});
+/** Whether following `extends` from the definition comes back to it. */
+const isInCycle = (definition, index) => {
+	const seen = /* @__PURE__ */ new Set();
+	let current = definition;
+	while (current && isModelDefinition(current) && current.extends !== void 0 && !seen.has(current.id)) {
+		seen.add(current.id);
+		if (current.extends === definition.id) return true;
+		current = index.get(current.extends);
+	}
+	return false;
+};
+const parentIssues = (definition, index) => {
+	if (definition.extends === void 0) return [];
+	if (definition.kind !== "collection") return [issue("/extends", "INVALID_PARENT", `only a collection can extend another; this is a ${definition.kind}`)];
+	const chain = ancestorChain(definition, index.get);
+	const parent = index.get(definition.extends);
+	switch (chain.problem) {
+		case "missing": return chain.problemAt === definition.id ? [issue("/extends", "UNKNOWN_PARENT", "extends a type that does not exist")] : [];
+		case "invalid":
+			if (chain.problemAt !== definition.id) return [];
+			return [issue("/extends", "INVALID_PARENT", definition.extends === definition.id ? "a type cannot extend itself" : `can only extend a collection; "${parent?.apiKey ?? definition.extends}" is a ${parent?.kind ?? "definition"}`)];
+		case "cycle": return isInCycle(definition, index) ? [issue("/extends", "INHERITANCE_CYCLE", "types extend each other in a cycle")] : [];
+		case "tooDeep": return [issue("/extends", "INHERITANCE_TOO_DEEP", `a family can have at most 8 levels of types`)];
+		default: return [];
+	}
+};
+const FLAGS = ["localized", "draftAndPublish"];
+const flagIssues = (definition, parent) => FLAGS.filter((flag) => definition[flag] !== parent[flag]).map((flag) => issue(`/${flag}`, "INHERITED_FLAG_MISMATCH", `must equal the parent's: set "${flag}" to ${String(parent[flag])}, as "${parent.apiKey}" has it`));
+const collisionIssues = (definition, index) => {
+	const resolved = index.resolve(definition.id);
+	const inherited = /* @__PURE__ */ new Map();
+	for (const field of resolved?.fields ?? []) if (field.inheritedFrom !== void 0) inherited.set(foldApiKey(field.apiKey), index.get(field.inheritedFrom)?.apiKey ?? field.inheritedFrom);
+	return definition.fields.flatMap((field, position) => {
+		const owner = inherited.get(foldApiKey(field.apiKey));
+		return owner === void 0 ? [] : [issue(`/fields/${position}/apiKey`, "INHERITED_FIELD_COLLISION", `"${field.apiKey}" is already a field of "${owner}", which this type extends (keys are case-insensitive)`)];
+	});
+};
+const GROUP_PATH = /^\/display\/groups\/(\d+)(\/.*)?$/;
+/**
+* The display checked against the resolved fields. An issue counts when it is about a value the child sets
+* itself (the parent's own values were checked on the parent); group paths are moved to the child's groups.
+*/
+const displayIssues = (definition, index) => {
+	const resolved = index.resolve(definition.id);
+	if (!resolved) return [];
+	const inheritedGroups = (resolved.display.groups?.length ?? 0) - (definition.display.groups?.length ?? 0);
+	const own = definition.display;
+	return checkDisplay(resolved).flatMap((found) => {
+		const group = GROUP_PATH.exec(found.path);
+		if (group) {
+			const position = Number(group[1]) - inheritedGroups;
+			return position < 0 ? [] : [{
+				...found,
+				path: `/display/groups/${position}${group[2] ?? ""}`
+			}];
+		}
+		const property = found.path.split("/")[2];
+		return property !== void 0 && own[property] !== void 0 ? [found] : [];
+	});
+};
+/** Every inheritance problem of a schema (see the module comment). */
+const checkInheritance = (definitions, index = createDefinitionIndex(definitions)) => definitions.flatMap((definition) => {
+	if (!isModelDefinition(definition) || definition.extends === void 0) return [];
+	const problems = parentIssues(definition, index);
+	const parent = index.get(definition.extends);
+	const checks = problems.length === 0 && parent && isModelDefinition(parent) ? [
+		...flagIssues(definition, parent),
+		...collisionIssues(definition, index),
+		...displayIssues(definition, index)
+	] : [];
+	return [...problems, ...checks].map((found) => withDefinition$1(definition, found));
+});
+//#endregion
 //#region src/validators/parse.ts
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const structuralIssues = (raw) => {
@@ -1622,7 +1905,8 @@ const checkGeneratedNames = (definitions) => {
 	const byId = new Map(definitions.map((definition) => [definition.id, definition]));
 	const issues = [];
 	const seen = /* @__PURE__ */ new Map();
-	for (const definition of definitions) for (const name of generatedNames(definition)) {
+	const parents = new Set(definitions.flatMap((definition) => isModelDefinition(definition) && definition.extends !== void 0 ? [definition.extends] : []));
+	for (const definition of definitions) for (const name of generatedNames(definition, { hasChildren: parents.has(definition.id) })) {
 		const folded = `${name.namespace}:${foldApiKey(name.name)}`;
 		const path = name.fieldId ? `/fields/${definition.fields.findIndex((field) => field.id === name.fieldId)}/apiKey` : `/${name.property ?? "apiKey"}`;
 		if (name.namespace === "type" && RESERVED_TYPES.has(foldApiKey(name.name))) {
@@ -1712,11 +1996,12 @@ const checkNesting = (definitions) => {
 };
 /**
 * Cross-definition checks over a whole schema (every active definition with the proposed change applied):
-* unique IDs and API keys, GraphQL name collisions, relation and component targets, component cycles and
-* nesting depth. Each definition must already pass `validateDefinition`.
+* unique IDs and API keys, model inheritance, GraphQL name collisions, relation and component targets,
+* component cycles and nesting depth. Each definition must already pass `validateDefinition`.
 */
 const validateSchema = (definitions) => [
 	...checkIdentity(definitions),
+	...checkInheritance(definitions),
 	...checkGeneratedNames(definitions),
 	...checkReferences(definitions),
 	...checkNesting(definitions)
@@ -1724,12 +2009,14 @@ const validateSchema = (definitions) => [
 /** Definitions that reference `id` (relations, components, dynamic zones). Used to block deletions. */
 const findReferencingDefinitions = (definitions, id) => definitions.filter((definition) => definition.id !== id && definition.fields.some((field) => field.type === "relation" && field.settings.target === id || field.type === "component" && field.settings.component === id || field.type === "dynamiczone" && field.settings.components.includes(id)));
 /**
-* Models that embed a component directly or through other components, i.e. whose entries change shape
-* when the component does (brief §5: "editing a shared component must account for all dependent models").
+* Models that embed a component directly, through other components or through an inherited field, i.e.
+* whose entries change shape when the component does (brief §5: "editing a shared component must account for
+* all dependent models").
 */
 const findDependentModels = (definitions, componentId) => {
 	const embeddedBy = /* @__PURE__ */ new Map();
 	for (const definition of definitions) for (const child of embeddedComponentIds(definition)) embeddedBy.set(child, [...embeddedBy.get(child) ?? [], definition]);
+	const index = createDefinitionIndex(definitions);
 	const models = /* @__PURE__ */ new Map();
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [componentId];
@@ -1738,7 +2025,10 @@ const findDependentModels = (definitions, componentId) => {
 		if (visited.has(current)) continue;
 		visited.add(current);
 		for (const parent of embeddedBy.get(current) ?? []) if (parent.kind === "component") queue.push(parent.id);
-		else models.set(parent.id, parent);
+		else for (const id of index.family(parent.id)) {
+			const model = index.get(id);
+			if (model) models.set(id, model);
+		}
 	}
 	return [...models.values()];
 };
@@ -1753,6 +2043,7 @@ const CHANGE_KINDS = [
 	"model.kind",
 	"model.localized",
 	"model.draftAndPublish",
+	"model.extends",
 	"field.added",
 	"field.removed",
 	"field.order",
@@ -1922,6 +2213,12 @@ const diffDefinitions = (before, after) => {
 		});
 	}
 	if (before.kind !== "component" && after.kind !== "component") {
+		if ((before.extends ?? null) !== (after.extends ?? null)) changes.push({
+			kind: "model.extends",
+			definitionId,
+			from: before.extends ?? null,
+			to: after.extends ?? null
+		});
 		if (before.localized !== after.localized) changes.push({
 			kind: "model.localized",
 			definitionId,
@@ -2060,8 +2357,12 @@ const convertsAcrossFamilies = (from, to) => {
 * that flag rather than deciding again from the type names.
 */
 const typeChangeDropsValues = (from, to) => storageFamilyOf(from) !== storageFamilyOf(to) && !convertsAcrossFamilies(from, to);
-/** Whether a (classified) change drops every stored value of its field; false for plans without the flag. */
-const changeDropsValues = (change) => change.kind === "field.type" && change.dropsValues === true;
+/**
+* Whether a (classified) change drops every stored value of its field; false for plans without the flag. A
+* type change Shapio cannot convert, or an inherited field a model loses when it moves to another parent
+* (`field.removed` marked by the planner, plan polymorphic-types decision 6).
+*/
+const changeDropsValues = (change) => (change.kind === "field.type" || change.kind === "field.removed") && change.dropsValues === true;
 /** A required field whose values are dropped is backfilled from its default, else checked (no silent nulls). */
 const requiredStep = (field) => {
 	if (!field?.required) return [];
@@ -2243,6 +2544,9 @@ const classifyChange = (change, context) => {
 			});
 			break;
 		}
+		case "model.extends":
+			classification = result("contract", { breaking: true });
+			break;
 		case "model.draftAndPublish":
 			classification = change.to === true ? result("additive") : result("conversion", {
 				destructive: true,
@@ -2885,6 +3189,6 @@ const SeoDefaultsSchema = Type.Object({
 	twitterHandle: Type.Union([Type.String({ pattern: SEO_TWITTER_HANDLE_PATTERN.source }), Type.Null()])
 }, closed);
 //#endregion
-export { API_KEY_PATTERN, BIGINTEGER_PATTERN, BUILT_IN_THEME_KEYS, CANVAS_ELIGIBLE, CHANGE_KINDS, CODE_LANGUAGES, COMPONENT_TYPE_SUFFIXES, CUSTOM_EDITOR_ID_PATTERN, ComponentDefinitionInputSchema, ComponentDisplayInputSchema, DATA_TYPES, DATETIME_PATTERN, DATE_PATTERN, DECIMAL_PATTERN, DEFAULT_EDITORS, DEFAULT_SEO_KEYS, DEFINITION_KINDS, DefinitionInputSchema, EDITOR_CATALOGUE, EMPTY_SEO_DEFAULTS, ENTRY_LAYOUTS, EditorChoiceInputSchema, EnumValueSchema, FIELD_WIDTHS, FieldInputSchema, INLINE_TITLE_TYPES, INVALID_TEXT_MESSAGE, LOCALE_CODE_PATTERN, LOCK_FILE_FORMAT_VERSION, LOCK_FILE_PATH, LocaleInputSchema, LockEntrySchema, LockFileError, LockFileSchema, MARK_RULES, MAX_API_KEY_LENGTH, MAX_COMPONENT_DEPTH, MAX_DESCRIPTION_LENGTH, MAX_FALLBACK_CHAIN, MAX_FIELDS_PER_DEFINITION, MAX_LABEL_LENGTH, MAX_RICHTEXT_DEPTH, MEDIA_KINDS, MODEL_KINDS, MODEL_TYPE_SUFFIXES, MUTATION_PREFIXES, ModelDefinitionInputSchema, ModelDisplayInputSchema, NODE_RULES, PLURAL_FALLBACK_SUFFIX, REFERENCE_DATA_TYPES, RELATION_CARDINALITIES, RESERVED_DEFINITION_API_KEYS, RESERVED_FIELD_API_KEYS, RESERVED_QUERY_NAMES, RESERVED_TYPE_NAMES, RICHTEXT_FORMAT, RICHTEXT_FORMAT_VERSION, SAFE_LINK_PATTERN, SCALAR_DATA_TYPES, SCHEMA_KIND_DIRECTORIES, SEO_COMPONENT_API_KEY, SEO_COMPONENT_ID, SEO_DESCRIPTION_SOFT_MAX, SEO_EDITOR_ID, SEO_FIELD_IDS, SEO_TITLE_PLACEHOLDER, SEO_TITLE_SOFT_MAX, SEO_TITLE_TEMPLATE_PATTERN, SEO_TWITTER_HANDLE_PATTERN, SETTINGS_SCHEMAS, SITES_DIRECTORY, SLUG_PATTERN, SORT_DIRECTIONS, STABLE_ID_PATTERN, STORAGE_FAMILY, STRIP_DEFAULT_COUNT, SchemaValidationError, SeoDefaultsSchema, SeoLocaleDefaultsSchema, TEXT_TITLE_FIELD_TYPES, THEME_BRAND_TOKENS, THEME_COLOUR_PATTERN, THEME_DARK_UI_PAIRS, THEME_KEY_PATTERN, THEME_SEMANTIC_TOKENS, THEME_TEXT_PAIRS, THEME_TOKENS, THEME_UI_PAIRS, THEME_VARIANTS, TIME_PATTERN, TITLE_FIELD_TYPES, UID_PATTERN, UNIQUE_CAPABLE_DATA_TYPES, applyTitleTemplate, assignIds, canonicalJson, changeDropsValues, checkApiKeySyntax, checkDefaultValue, checkThemeContrast, classifyChange, classifyChanges, classifyLocaleChange, collectionQueryName, contrastRatio, createStableId, decideSync, diffDefinitions, effectiveFormLayout, effectiveLayout, effectiveTitleField, embeddedComponentIds, entryLayoutOf, escapeHtml, findDependentModels, findInvalidText, findReferencingDefinitions, foldApiKey, generatedNames, hashDefinition, isApiKeySyntaxValid, isCanvasEligible, isComponentDefinition, isCoverEligible, isCustomEditorId, isDataType, isDocumentPlaceable, isEmptyRichText, isModelDefinition, isSeoField, isStableId, isValidText, isValidTitleTemplate, issue, listCompatibleEditors, lockCoversSite, lockEntriesForSite, mergePulledLock, normalizeDefinition, parseDefinition, parseLockFile, plainTextToRichText, renderRichTextHtml, renormalizeDefinition, resolveSeo, richTextBodyOf, richTextMediaIds, richTextPlainText, richTextToPlainText, routeKeyOf, schemaFilePath, scopeDirectory, scopeOfSchemaFilePath, seoComponentDefinition, seoDefaultsForLocale, serializeDefinition, serializeLockFile, sha256, storageFamilyOf, stripFieldsOf, suggestPlural, summarizeChanges, toTypeName, typeChangeDropsValues, uniqueFieldsChangingLocalization, upgradeLockFile, validateDefinition, validateRichText, validateSchema, withDerivedPlural, withSiteCovered };
+export { API_KEY_PATTERN, BIGINTEGER_PATTERN, BUILT_IN_THEME_KEYS, CANVAS_ELIGIBLE, CHANGE_KINDS, CODE_LANGUAGES, COMPONENT_TYPE_SUFFIXES, CUSTOM_EDITOR_ID_PATTERN, ComponentDefinitionInputSchema, ComponentDisplayInputSchema, DATA_TYPES, DATETIME_PATTERN, DATE_PATTERN, DECIMAL_PATTERN, DEFAULT_EDITORS, DEFAULT_SEO_KEYS, DEFINITION_KINDS, DefinitionInputSchema, EDITOR_CATALOGUE, EMPTY_SEO_DEFAULTS, ENTRY_LAYOUTS, EditorChoiceInputSchema, EnumValueSchema, FIELD_WIDTHS, FieldInputSchema, INLINE_TITLE_TYPES, INTERFACE_TYPE_SUFFIX, INVALID_TEXT_MESSAGE, LOCALE_CODE_PATTERN, LOCK_FILE_FORMAT_VERSION, LOCK_FILE_PATH, LocaleInputSchema, LockEntrySchema, LockFileError, LockFileSchema, MARK_RULES, MAX_API_KEY_LENGTH, MAX_COMPONENT_DEPTH, MAX_DESCRIPTION_LENGTH, MAX_FALLBACK_CHAIN, MAX_FIELDS_PER_DEFINITION, MAX_INHERITANCE_DEPTH, MAX_LABEL_LENGTH, MAX_RICHTEXT_DEPTH, MAX_ROUTE_KEY_LENGTH, MEDIA_KINDS, MODEL_KINDS, MODEL_TYPE_SUFFIXES, MUTATION_PREFIXES, ModelDefinitionInputSchema, ModelDisplayInputSchema, NODE_RULES, PLURAL_FALLBACK_SUFFIX, REFERENCE_DATA_TYPES, RELATION_CARDINALITIES, RESERVED_DEFINITION_API_KEYS, RESERVED_FIELD_API_KEYS, RESERVED_QUERY_NAMES, RESERVED_TYPE_NAMES, RICHTEXT_FORMAT, RICHTEXT_FORMAT_VERSION, ROUTE_KEY_PATTERN, SAFE_LINK_PATTERN, SCALAR_DATA_TYPES, SCHEMA_KIND_DIRECTORIES, SEO_COMPONENT_API_KEY, SEO_COMPONENT_ID, SEO_DESCRIPTION_SOFT_MAX, SEO_EDITOR_ID, SEO_FIELD_IDS, SEO_TITLE_PLACEHOLDER, SEO_TITLE_SOFT_MAX, SEO_TITLE_TEMPLATE_PATTERN, SEO_TWITTER_HANDLE_PATTERN, SETTINGS_SCHEMAS, SITES_DIRECTORY, SLUG_PATTERN, SORT_DIRECTIONS, STABLE_ID_PATTERN, STORAGE_FAMILY, STRIP_DEFAULT_COUNT, SchemaValidationError, SeoDefaultsSchema, SeoLocaleDefaultsSchema, TEXT_TITLE_FIELD_TYPES, THEME_BRAND_TOKENS, THEME_COLOUR_PATTERN, THEME_DARK_UI_PAIRS, THEME_KEY_PATTERN, THEME_SEMANTIC_TOKENS, THEME_TEXT_PAIRS, THEME_TOKENS, THEME_UI_PAIRS, THEME_VARIANTS, TIME_PATTERN, TITLE_FIELD_TYPES, UID_PATTERN, UNIQUE_CAPABLE_DATA_TYPES, ancestorChain, applyTitleTemplate, assignIds, canonicalJson, changeDropsValues, checkApiKeySyntax, checkDefaultValue, checkDisplay, checkInheritance, checkThemeContrast, classifyChange, classifyChanges, classifyLocaleChange, collectionQueryName, contrastRatio, createDefinitionIndex, createStableId, decideSync, diffDefinitions, effectiveFormLayout, effectiveLayout, effectiveTitleField, embeddedComponentIds, entryLayoutOf, escapeHtml, findChildDefinitions, findDependentModels, findInvalidText, findReferencingDefinitions, foldApiKey, generatedNames, hashDefinition, isApiKeySyntaxValid, isCanvasEligible, isComponentDefinition, isCoverEligible, isCustomEditorId, isDataType, isDocumentPlaceable, isEmptyRichText, isModelDefinition, isSeoField, isStableId, isValidText, isValidTitleTemplate, issue, listCompatibleEditors, lockCoversSite, lockEntriesForSite, mergeDisplay, mergePulledLock, normalizeDefinition, ownFields, parseDefinition, parseLockFile, plainTextToRichText, renderRichTextHtml, renormalizeDefinition, resolveModelDefinition, resolveSeo, richTextBodyOf, richTextMediaIds, richTextPlainText, richTextToPlainText, routeKeyOf, routePathOf, schemaFilePath, scopeDirectory, scopeOfSchemaFilePath, seoComponentDefinition, seoDefaultsForLocale, serializeDefinition, serializeLockFile, sha256, splitRoutePath, storageFamilyOf, stripFieldsOf, suggestPlural, summarizeChanges, toTypeName, typeChangeDropsValues, uniqueFieldsChangingLocalization, upgradeLockFile, validateDefinition, validateRichText, validateSchema, withDerivedPlural, withSiteCovered };
 
 //# sourceMappingURL=index.js.map