@shapio/schema 0.2.0

package/dist/index.js

@@ -0,0 +1,2268 @@
+import { _ as STABLE_ID_PATTERN, a as MAX_RICHTEXT_DEPTH, c as BIGINTEGER_PATTERN, d as DECIMAL_PATTERN, f as RICHTEXT_FORMAT, g as UID_PATTERN, h as TIME_PATTERN, i as MARK_RULES, l as DATETIME_PATTERN, m as SLUG_PATTERN, n as richTextMediaIds, o as NODE_RULES, p as RICHTEXT_FORMAT_VERSION, r as validateRichText, s as SAFE_LINK_PATTERN, t as isEmptyRichText, u as DATE_PATTERN, v as createStableId, y as isStableId } from "./validate-BQGutaBo.js";
+import { Type } from "typebox";
+import pluralize from "pluralize";
+import { Value } from "typebox/value";
+//#region src/types/dataTypes.ts
+/** Every stored data type. A field's data type is separate from the editor that renders it (brief §2.5). */
+const DATA_TYPES = [
+	"string",
+	"text",
+	"richtext",
+	"number",
+	"integer",
+	"decimal",
+	"biginteger",
+	"boolean",
+	"date",
+	"datetime",
+	"time",
+	"enum",
+	"json",
+	"slug",
+	"email",
+	"url",
+	"uid",
+	"media",
+	"relation",
+	"component",
+	"dynamiczone"
+];
+const isDataType = (value) => typeof value === "string" && DATA_TYPES.includes(value);
+/**
+* Scalar types stored as one JSON value per field (string, number or boolean). Only these can be unique,
+* filterable or sortable: their index expression is a single cast of `data ->> fieldId` (ADR 0001).
+*/
+const SCALAR_DATA_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"text",
+	"number",
+	"integer",
+	"decimal",
+	"biginteger",
+	"boolean",
+	"date",
+	"datetime",
+	"time",
+	"enum",
+	"slug",
+	"email",
+	"url",
+	"uid"
+]);
+/** Types that may carry `unique: true` (boolean and long text make no sense as unique keys). */
+const UNIQUE_CAPABLE_DATA_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"decimal",
+	"biginteger",
+	"date",
+	"datetime",
+	"time",
+	"slug",
+	"email",
+	"url",
+	"uid"
+]);
+/** Types whose values point at other definitions; the reference checks look at these. */
+const REFERENCE_DATA_TYPES = /* @__PURE__ */ new Set([
+	"relation",
+	"component",
+	"dynamiczone"
+]);
+const STORAGE_FAMILY = {
+	string: "jsonString",
+	text: "jsonString",
+	slug: "jsonString",
+	email: "jsonString",
+	url: "jsonString",
+	uid: "jsonString",
+	enum: "jsonString",
+	date: "jsonString",
+	datetime: "jsonString",
+	time: "jsonString",
+	number: "jsonNumber",
+	integer: "jsonNumber",
+	decimal: "numericString",
+	biginteger: "numericString",
+	boolean: "boolean",
+	json: "json",
+	richtext: "richtext",
+	media: "media",
+	relation: "relation",
+	component: "component",
+	dynamiczone: "dynamiczone"
+};
+//#endregion
+//#region src/types/definitions.ts
+/**
+* Model and component definitions. Both kinds share one table (`models`, with a `kind` discriminator) but
+* have distinct TypeScript types: a component cannot be published, localised or addressed by a route.
+*
+* The `*InputSchema` TypeBox schemas describe what callers send and what schema files contain: IDs and
+* defaulted properties may be omitted. `normalizeDefinition` turns input into the normalized types below,
+* which are what Shapio stores, hashes and diffs.
+*/
+const closed$2 = { additionalProperties: false };
+const MODEL_KINDS = ["collection", "singleton"];
+const DEFINITION_KINDS = [...MODEL_KINDS, "component"];
+const SORT_DIRECTIONS = ["asc", "desc"];
+const MAX_FIELDS_PER_DEFINITION = 500;
+const MAX_LABEL_LENGTH = 200;
+const MAX_DESCRIPTION_LENGTH = 2e3;
+const Label = Type.String({
+	minLength: 1,
+	maxLength: 200
+});
+const Description = Type.Optional(Type.String({ maxLength: MAX_DESCRIPTION_LENGTH }));
+const EditorChoiceInputSchema = Type.Object({
+	id: Type.String({
+		minLength: 1,
+		maxLength: 128
+	}),
+	options: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+}, closed$2);
+const FieldInputSchema = Type.Object({
+	id: Type.Optional(Type.String()),
+	apiKey: Type.String(),
+	label: Label,
+	/** Help text shown under the control. */
+	description: Description,
+	type: Type.Enum(DATA_TYPES),
+	required: Type.Optional(Type.Boolean()),
+	/** Per-locale value. Ignored (must be false) when the model is not localized. */
+	localized: Type.Optional(Type.Boolean()),
+	/** Readable by delivery principals wherever the model is readable (ADR 0005). Default true. */
+	public: Type.Optional(Type.Boolean()),
+	unique: Type.Optional(Type.Boolean()),
+	filterable: Type.Optional(Type.Boolean()),
+	sortable: Type.Optional(Type.Boolean()),
+	/** Hidden from editors and the API; stored values are preserved until an explicit cleanup. */
+	deprecated: Type.Optional(Type.Boolean()),
+	/** Used for new entries and to backfill existing ones when the field becomes required. */
+	defaultValue: Type.Optional(Type.Unknown()),
+	/** Type-specific settings, validated against SETTINGS_SCHEMAS[type]. */
+	settings: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+	editor: Type.Optional(EditorChoiceInputSchema)
+}, closed$2);
+const FieldGroupSchema = Type.Object({
+	id: Type.String({
+		minLength: 1,
+		maxLength: 64
+	}),
+	label: Label,
+	fieldIds: Type.Array(Type.String())
+}, closed$2);
+const ModelDisplayInputSchema = Type.Object({
+	/** Field whose value labels an entry in lists, pickers and relation summaries. */
+	titleFieldId: Type.Optional(Type.String()),
+	/** Columns of the content list, in order. */
+	listFieldIds: Type.Optional(Type.Array(Type.String())),
+	defaultSort: Type.Optional(Type.Object({
+		fieldId: Type.String(),
+		direction: Type.Enum(SORT_DIRECTIONS)
+	}, closed$2)),
+	/** Editor layout: named sections of the entry form. */
+	groups: Type.Optional(Type.Array(FieldGroupSchema)),
+	/** Fields rendered as blocks in the entry document's canvas, in order. Default: see `effectiveLayout`. */
+	canvasFieldIds: Type.Optional(Type.Array(Type.String())),
+	/** A single image `media` field shown as the cover above the title. Default: see `effectiveLayout`. */
+	coverFieldId: Type.Optional(Type.String()),
+	/** Properties shown as chips in the document's strip. Default: the first non-empty ones. */
+	stripFieldIds: Type.Optional(Type.Array(Type.String()))
+}, closed$2);
+const ComponentDisplayInputSchema = Type.Object({
+	titleFieldId: Type.Optional(Type.String()),
+	groups: Type.Optional(Type.Array(FieldGroupSchema))
+}, closed$2);
+const definitionBase = {
+	id: Type.Optional(Type.String()),
+	apiKey: Type.String(),
+	label: Label,
+	description: Description,
+	fields: Type.Array(FieldInputSchema, { maxItems: 500 })
+};
+const ModelDefinitionInputSchema = Type.Object({
+	...definitionBase,
+	kind: Type.Enum(MODEL_KINDS),
+	/**
+	* Collections only: names the list route and query (`/api/content/articles`, `articles(…)`). Optional
+	* here so files written before plural API IDs still parse; normalizing fills it on a collection.
+	*/
+	pluralApiKey: Type.Optional(Type.String()),
+	localized: Type.Optional(Type.Boolean()),
+	/** Entries have separate draft and published states. Default true. */
+	draftAndPublish: Type.Optional(Type.Boolean()),
+	display: Type.Optional(ModelDisplayInputSchema)
+}, closed$2);
+const ComponentDefinitionInputSchema = Type.Object({
+	...definitionBase,
+	kind: Type.Literal("component"),
+	category: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 100
+	})),
+	icon: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 64
+	})),
+	display: Type.Optional(ComponentDisplayInputSchema)
+}, closed$2);
+const DefinitionInputSchema = Type.Union([ModelDefinitionInputSchema, ComponentDefinitionInputSchema]);
+const isComponentDefinition = (definition) => definition.kind === "component";
+const isModelDefinition = (definition) => definition.kind !== "component";
+//#endregion
+//#region src/types/locales.ts
+/** BCP 47 subset: language (2–3 letters) plus optional subtags, e.g. `en`, `fr-CA`, `zh-Hant-TW`. */
+const LOCALE_CODE_PATTERN = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+const MAX_FALLBACK_CHAIN = 10;
+const LocaleInputSchema = Type.Object({
+	code: Type.String({
+		pattern: LOCALE_CODE_PATTERN.source,
+		maxLength: 35
+	}),
+	label: Type.String({
+		minLength: 1,
+		maxLength: 100
+	}),
+	/** Locales tried in order when content is missing in this one; the default locale is always last. */
+	fallbacks: Type.Optional(Type.Array(Type.String(), { maxItems: 10 }))
+}, { additionalProperties: false });
+//#endregion
+//#region src/types/settings.ts
+/**
+* Per-data-type settings: validation rules and type configuration (relation target, component reference,
+* enum values...). Each schema is closed (`additionalProperties: false`) so a typo in a hand-edited schema
+* file is reported instead of ignored. Defaults are applied by `normalizeDefinition`.
+*/
+const closed$1 = { additionalProperties: false };
+const NonNegativeInt = Type.Integer({ minimum: 0 });
+const pattern = (regex) => Type.String({ pattern: regex.source });
+const lengthRules = {
+	minLength: Type.Optional(NonNegativeInt),
+	maxLength: Type.Optional(Type.Integer({ minimum: 1 }))
+};
+const countRules = {
+	min: Type.Optional(NonNegativeInt),
+	max: Type.Optional(Type.Integer({ minimum: 1 }))
+};
+const MEDIA_KINDS = [
+	"image",
+	"video",
+	"audio",
+	"document",
+	"other"
+];
+const RELATION_CARDINALITIES = ["one", "many"];
+const EnumValueSchema = Type.Object({
+	value: Type.String({
+		minLength: 1,
+		maxLength: 64
+	}),
+	label: Type.String({
+		minLength: 1,
+		maxLength: 200
+	})
+}, closed$1);
+const SETTINGS_SCHEMAS = {
+	string: Type.Object({
+		...lengthRules,
+		pattern: Type.Optional(Type.String({
+			minLength: 1,
+			maxLength: 500
+		}))
+	}, closed$1),
+	text: Type.Object(lengthRules, closed$1),
+	richtext: Type.Object({
+		formatVersion: Type.Optional(Type.Integer({ minimum: 1 })),
+		maxLength: Type.Optional(Type.Integer({ minimum: 1 }))
+	}, closed$1),
+	number: Type.Object({
+		min: Type.Optional(Type.Number()),
+		max: Type.Optional(Type.Number())
+	}, closed$1),
+	integer: Type.Object({
+		min: Type.Optional(Type.Integer()),
+		max: Type.Optional(Type.Integer())
+	}, closed$1),
+	decimal: Type.Object({
+		precision: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 1e3
+		})),
+		scale: Type.Optional(Type.Integer({
+			minimum: 0,
+			maximum: 1e3
+		})),
+		min: Type.Optional(pattern(DECIMAL_PATTERN)),
+		max: Type.Optional(pattern(DECIMAL_PATTERN))
+	}, closed$1),
+	biginteger: Type.Object({
+		min: Type.Optional(pattern(BIGINTEGER_PATTERN)),
+		max: Type.Optional(pattern(BIGINTEGER_PATTERN))
+	}, closed$1),
+	boolean: Type.Object({}, closed$1),
+	date: Type.Object({
+		min: Type.Optional(pattern(DATE_PATTERN)),
+		max: Type.Optional(pattern(DATE_PATTERN))
+	}, closed$1),
+	datetime: Type.Object({
+		min: Type.Optional(pattern(DATETIME_PATTERN)),
+		max: Type.Optional(pattern(DATETIME_PATTERN))
+	}, closed$1),
+	time: Type.Object({
+		min: Type.Optional(pattern(TIME_PATTERN)),
+		max: Type.Optional(pattern(TIME_PATTERN))
+	}, closed$1),
+	enum: Type.Object({
+		values: Type.Array(EnumValueSchema, {
+			minItems: 1,
+			maxItems: 500
+		}),
+		multiple: Type.Optional(Type.Boolean())
+	}, closed$1),
+	json: Type.Object({}, closed$1),
+	slug: Type.Object({
+		...lengthRules,
+		sourceFieldId: Type.Optional(Type.String())
+	}, closed$1),
+	email: Type.Object({}, closed$1),
+	url: Type.Object({ protocols: Type.Optional(Type.Array(Type.Enum([
+		"http",
+		"https",
+		"mailto",
+		"tel"
+	]), { minItems: 1 })) }, closed$1),
+	uid: Type.Object(lengthRules, closed$1),
+	media: Type.Object({
+		multiple: Type.Optional(Type.Boolean()),
+		allowedKinds: Type.Optional(Type.Array(Type.Enum(MEDIA_KINDS), { minItems: 1 })),
+		...countRules
+	}, closed$1),
+	relation: Type.Object({
+		target: Type.String(),
+		cardinality: Type.Enum(RELATION_CARDINALITIES),
+		...countRules
+	}, closed$1),
+	component: Type.Object({
+		component: Type.String(),
+		repeatable: Type.Optional(Type.Boolean()),
+		...countRules
+	}, closed$1),
+	dynamiczone: Type.Object({
+		components: Type.Array(Type.String(), {
+			minItems: 1,
+			maxItems: 100
+		}),
+		...countRules
+	}, closed$1)
+};
+//#endregion
+//#region src/editors/catalogue.ts
+const closed = { additionalProperties: false };
+const Placeholder = Type.Optional(Type.String({ maxLength: 200 }));
+const isMultipleEnum = (field) => field.type === "enum" && field.settings.multiple;
+const entries = [
+	{
+		id: "textInput",
+		dataTypes: [
+			"string",
+			"email",
+			"url",
+			"uid"
+		],
+		optionsSchema: Type.Object({ placeholder: Placeholder }, closed)
+	},
+	{
+		id: "textarea",
+		dataTypes: ["text", "string"],
+		optionsSchema: Type.Object({
+			placeholder: Placeholder,
+			rows: Type.Optional(Type.Integer({
+				minimum: 2,
+				maximum: 40
+			}))
+		}, closed)
+	},
+	{
+		id: "color",
+		dataTypes: ["string"],
+		optionsSchema: Type.Object({
+			format: Type.Optional(Type.Enum(["hex", "rgb"])),
+			presets: Type.Optional(Type.Array(Type.String({ maxLength: 32 }), { maxItems: 50 }))
+		}, closed)
+	},
+	{
+		id: "richText",
+		dataTypes: ["richtext"],
+		optionsSchema: Type.Object({ toolbar: Type.Optional(Type.Enum(["full", "minimal"])) }, closed)
+	},
+	{
+		id: "numberInput",
+		dataTypes: [
+			"number",
+			"integer",
+			"decimal",
+			"biginteger"
+		],
+		optionsSchema: Type.Object({
+			placeholder: Placeholder,
+			step: Type.Optional(Type.Number({ exclusiveMinimum: 0 }))
+		}, closed)
+	},
+	{
+		id: "toggle",
+		dataTypes: ["boolean"],
+		optionsSchema: Type.Object({}, closed)
+	},
+	{
+		id: "checkbox",
+		dataTypes: ["boolean"],
+		optionsSchema: Type.Object({}, closed)
+	},
+	{
+		id: "segmented",
+		dataTypes: ["boolean", "enum"],
+		optionsSchema: Type.Object({
+			trueLabel: Type.Optional(Type.String({ maxLength: 50 })),
+			falseLabel: Type.Optional(Type.String({ maxLength: 50 }))
+		}, closed),
+		supports: (field) => !isMultipleEnum(field)
+	},
+	{
+		id: "select",
+		dataTypes: ["enum"],
+		optionsSchema: Type.Object({ placeholder: Placeholder }, closed)
+	},
+	{
+		id: "radio",
+		dataTypes: ["enum"],
+		optionsSchema: Type.Object({ layout: Type.Optional(Type.Enum(["vertical", "horizontal"])) }, closed),
+		supports: (field) => !isMultipleEnum(field)
+	},
+	{
+		id: "checkboxGroup",
+		dataTypes: ["enum"],
+		optionsSchema: Type.Object({ layout: Type.Optional(Type.Enum(["vertical", "horizontal"])) }, closed),
+		supports: isMultipleEnum
+	},
+	{
+		id: "datePicker",
+		dataTypes: ["date"],
+		optionsSchema: Type.Object({}, closed)
+	},
+	{
+		id: "dateTimePicker",
+		dataTypes: ["datetime"],
+		optionsSchema: Type.Object({ display: Type.Optional(Type.Enum(["local", "utc"])) }, closed)
+	},
+	{
+		id: "timePicker",
+		dataTypes: ["time"],
+		optionsSchema: Type.Object({ stepMinutes: Type.Optional(Type.Integer({
+			minimum: 1,
+			maximum: 60
+		})) }, closed)
+	},
+	{
+		id: "slugInput",
+		dataTypes: ["slug"],
+		optionsSchema: Type.Object({ placeholder: Placeholder }, closed)
+	},
+	{
+		id: "jsonEditor",
+		dataTypes: ["json"],
+		optionsSchema: Type.Object({ rows: Type.Optional(Type.Integer({
+			minimum: 3,
+			maximum: 80
+		})) }, closed)
+	},
+	{
+		id: "mediaPicker",
+		dataTypes: ["media"],
+		optionsSchema: Type.Object({}, closed)
+	},
+	{
+		id: "relationPicker",
+		dataTypes: ["relation"],
+		optionsSchema: Type.Object({ allowInlineCreate: Type.Optional(Type.Boolean()) }, closed)
+	},
+	{
+		id: "componentEditor",
+		dataTypes: ["component"],
+		optionsSchema: Type.Object({ collapsed: Type.Optional(Type.Boolean()) }, closed)
+	},
+	{
+		id: "dynamicZoneEditor",
+		dataTypes: ["dynamiczone"],
+		optionsSchema: Type.Object({ collapsed: Type.Optional(Type.Boolean()) }, closed)
+	}
+];
+const EDITOR_CATALOGUE = new Map(entries.map((entry) => [entry.id, entry]));
+/** The editor a field gets when its definition names none. */
+const DEFAULT_EDITORS = {
+	string: "textInput",
+	text: "textarea",
+	richtext: "richText",
+	number: "numberInput",
+	integer: "numberInput",
+	decimal: "numberInput",
+	biginteger: "numberInput",
+	boolean: "toggle",
+	date: "datePicker",
+	datetime: "dateTimePicker",
+	time: "timePicker",
+	enum: "select",
+	json: "jsonEditor",
+	slug: "slugInput",
+	email: "textInput",
+	url: "textInput",
+	uid: "textInput",
+	media: "mediaPicker",
+	relation: "relationPicker",
+	component: "componentEditor",
+	dynamiczone: "dynamicZoneEditor"
+};
+/** `vendor.name` (letters, digits, `_`, `-`), e.g. `acme.colorWheel`. Built-in IDs never contain a dot. */
+const CUSTOM_EDITOR_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*(\.[A-Za-z][A-Za-z0-9_-]*)+$/;
+const isCustomEditorId = (id) => CUSTOM_EDITOR_ID_PATTERN.test(id);
+/** Built-in editors that can edit this field (for the admin's editor picker). */
+const listCompatibleEditors = (field) => entries.filter((entry) => entry.dataTypes.includes(field.type) && (entry.supports?.(field) ?? true));
+//#endregion
+//#region src/display/titleField.ts
+/** Field types that may label entries: the only types `display.titleFieldId` accepts, and the fallback's. */
+const TITLE_FIELD_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"text",
+	"slug",
+	"email",
+	"uid",
+	"enum"
+]);
+/**
+* Field types the list API's `q` search runs on, checked on top of the title field: an enum title is not
+* searchable. `url` is listed for search only; it is never a title.
+*/
+const TEXT_TITLE_FIELD_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"text",
+	"slug",
+	"email",
+	"url",
+	"uid"
+]);
+/**
+* The field that labels a definition's entries in lists, pickers, relation summaries and search: the
+* configured `display.titleFieldId` when it points at a live (non-deprecated) field, otherwise the first
+* live field of a title type (TITLE_FIELD_TYPES) in field order, otherwise undefined. `titleFieldId` is
+* optional, so a model built without one still gets a readable title.
+*/
+const effectiveTitleField = (definition) => {
+	const live = definition.fields.filter((field) => !field.deprecated);
+	const configured = definition.display.titleFieldId;
+	return (configured === void 0 ? void 0 : live.find((field) => field.id === configured)) ?? live.find((field) => TITLE_FIELD_TYPES.has(field.type));
+};
+//#endregion
+//#region src/display/layout.ts
+/**
+* Data types that can be blocks in the entry document's canvas. Components must also be repeatable and
+* media must hold several files (`isCanvasEligible`); a single component or file is a property.
+*/
+const CANVAS_ELIGIBLE = /* @__PURE__ */ new Set([
+	"richtext",
+	"dynamiczone",
+	"component",
+	"media"
+]);
+/** Title types that the document edits inline as its H1; any other title type stays a property. */
+const INLINE_TITLE_TYPES = /* @__PURE__ */ new Set(["string", "text"]);
+/** How many properties the strip shows when `display.stripFieldIds` is not set. */
+const STRIP_DEFAULT_COUNT = 5;
+const isCanvasEligible = (field) => {
+	switch (field.type) {
+		case "richtext":
+		case "dynamiczone": return true;
+		case "component": return field.settings.repeatable;
+		case "media": return field.settings.multiple;
+		default: return false;
+	}
+};
+/** A single `media` field that may hold an image. */
+const isCoverEligible = (field) => field.type === "media" && !field.settings.multiple && (field.settings.allowedKinds === void 0 || field.settings.allowedKinds.includes("image"));
+const byIds = (live, ids) => (ids ?? []).map((id) => live.find((field) => field.id === id)).filter((field) => field !== void 0);
+const unique = (fields) => [...new Map(fields.map((f) => [f.id, f])).values()];
+const groupProperties = (model, properties) => {
+	const groups = (model.display.groups ?? []).map((group) => ({
+		id: group.id,
+		label: group.label,
+		fields: byIds(properties, group.fieldIds)
+	})).filter((group) => group.fields.length > 0);
+	const grouped = new Set(groups.flatMap((group) => group.fields.map((field) => field.id)));
+	const rest = properties.filter((field) => !grouped.has(field.id));
+	return rest.length > 0 ? [...groups, {
+		id: "other",
+		label: void 0,
+		fields: rest
+	}] : groups;
+};
+const coverOf = (model, live, canvas) => {
+	const configured = byIds(live, model.display.coverFieldId ? [model.display.coverFieldId] : [])[0];
+	if (configured && isCoverEligible(configured) && !canvas.has(configured.id)) return configured;
+	return live.find((field) => isCoverEligible(field) && !canvas.has(field.id));
+};
+/**
+* The entry document's layout: title, cover, canvas blocks and properties. Configured `display` ids win
+* when they point at live, eligible fields; anything else falls back to the defaults (canvas: every
+* eligible field in field order; cover: the first single image field). Deprecated and ineligible ids are
+* skipped, so a stale definition never breaks the editor. Pure: no values, no I/O.
+*/
+const effectiveLayout = (model) => {
+	const live = model.fields.filter((field) => !field.deprecated);
+	const title = effectiveTitleField(model);
+	const titleInline = title !== void 0 && INLINE_TITLE_TYPES.has(title.type);
+	const configuredCanvas = unique(byIds(live, model.display.canvasFieldIds).filter(isCanvasEligible));
+	const canvasCandidates = model.display.canvasFieldIds === void 0 ? live.filter(isCanvasEligible) : configuredCanvas;
+	const cover = coverOf(model, live, new Set(configuredCanvas.map((field) => field.id)));
+	const canvas = canvasCandidates.filter((field) => field.id !== cover?.id);
+	const placed = /* @__PURE__ */ new Set([
+		...canvas.map((field) => field.id),
+		...cover ? [cover.id] : [],
+		...titleInline && title ? [title.id] : []
+	]);
+	const propertyGroups = groupProperties(model, live.filter((field) => !placed.has(field.id)));
+	const properties = propertyGroups.flatMap((group) => group.fields);
+	return {
+		title,
+		titleInline,
+		cover,
+		canvas,
+		properties,
+		propertyGroups,
+		strip: model.display.stripFieldIds === void 0 ? null : unique(byIds(properties, model.display.stripFieldIds))
+	};
+};
+/** The strip's properties: the configured ones, or the first `limit` that `hasValue` says are non-empty. */
+const stripFieldsOf = (layout, hasValue, limit = 5) => layout.strip ?? layout.properties.filter(hasValue).slice(0, limit);
+//#endregion
+//#region src/validators/apiKey.ts
+/**
+* API keys (models, components, fields) must be valid GraphQL names from day one (CONTRIBUTING.md rule 4),
+* so GraphQL can expose them without renames.
+*/
+const API_KEY_PATTERN = /^[_A-Za-z][_0-9A-Za-z]*$/;
+const MAX_API_KEY_LENGTH = 64;
+const isApiKeySyntaxValid = (key) => API_KEY_PATTERN.test(key);
+/**
+* Syntax checks shared by every kind of API key (`noun` names it in messages, e.g. "plural API ID").
+* Returns the first problem, or null.
+*/
+const checkApiKeySyntax = (key, noun = "API ID") => {
+	if (!isApiKeySyntaxValid(key)) return {
+		code: "API_KEY_INVALID",
+		message: `"${key}" is not a valid ${noun}: use letters, digits and _, not starting with a digit`
+	};
+	if (key.length > 64) return {
+		code: "API_KEY_TOO_LONG",
+		message: `${noun}s are at most 64 characters`
+	};
+	if (key.startsWith("__")) return {
+		code: "API_KEY_RESERVED_PREFIX",
+		message: `${noun}s must not start with "__" (reserved by GraphQL)`
+	};
+	return null;
+};
+/** Case-folded form used for every collision check: `Title` and `title` collide. */
+const foldApiKey = (key) => key.toLowerCase();
+//#endregion
+//#region src/naming/plural.ts
+/** Appended when English has no distinct plural (`news` → `newsItems`, `series` → `seriesItems`). */
+const PLURAL_FALLBACK_SUFFIX = "Items";
+/**
+* Suggests the plural API ID of a collection from its singular one (`article` → `articles`,
+* `category` → `categories`). Only a suggestion for the admin and the value filled into definitions that
+* predate plural API IDs: the plural is stored on the definition and nothing pluralises at request time.
+* Deterministic for a given `pluralize` version, which is pinned exactly for that reason.
+*/
+const suggestPlural = (apiKey) => {
+	if (apiKey === "") return "";
+	const plural = pluralize(apiKey);
+	if (plural.length <= 64 && foldApiKey(plural) !== foldApiKey(apiKey)) return plural;
+	return `${apiKey.slice(0, 59)}${PLURAL_FALLBACK_SUFFIX}`;
+};
+//#endregion
+//#region src/normalize.ts
+const SETTINGS_DEFAULTS = {
+	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;
+	}
+	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 ?? {}
+		}
+	};
+	return withoutEmpty(normalized);
+};
+const normalizeModelDisplay = (display) => withoutEmpty({ ...display });
+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. 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,
+		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 "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/naming.ts
+/**
+* The names GraphQL (package J) and other generated contracts derive from API keys. Defined here, with the
+* validator, so a name that would collide in GraphQL is rejected when the model is saved, never later.
+* Package J must generate exactly these names.
+*/
+const toTypeName = (apiKey) => apiKey.charAt(0).toUpperCase() + apiKey.slice(1);
+/** Suffixes of the types generated for each model (`Page`, `PageFilter`, `PageInput`...). */
+const MODEL_TYPE_SUFFIXES = [
+	"",
+	"Filter",
+	"Input",
+	"Connection",
+	"Edge",
+	"Localizations",
+	"Sort"
+];
+const COMPONENT_TYPE_SUFFIXES = ["", "Input"];
+const MUTATION_PREFIXES = [
+	"create",
+	"update",
+	"delete",
+	"publish",
+	"unpublish"
+];
+/**
+* The key a model is addressed by in the delivery API (`/api/content/:routeKey`, preview routes): the
+* plural API ID of a collection, the API ID of a singleton. A collection stored before plural API IDs
+* existed gets the same derived value normalizing would fill, so this never returns undefined.
+*/
+const routeKeyOf = (definition) => definition.kind === "collection" ? definition.pluralApiKey || suggestPlural(definition.apiKey) : definition.apiKey;
+/** GraphQL list query of a collection (`articles(…)`): its plural API ID. */
+const collectionQueryName = (definition) => routeKeyOf(definition);
+/**
+* A stored definition with the plural API ID a collection gets when it predates them (the value
+* normalizing fills), and whether anything was filled. Callers that hash definitions re-hash when `filled`.
+*/
+const withDerivedPlural = (definition) => {
+	if (definition.kind !== "collection" || definition.pluralApiKey) return {
+		definition,
+		filled: false
+	};
+	const { id, kind, apiKey, ...rest } = definition;
+	return {
+		definition: {
+			id,
+			kind,
+			apiKey,
+			pluralApiKey: suggestPlural(apiKey),
+			...rest
+		},
+		filled: true
+	};
+};
+/**
+* GraphQL built-ins and the fixed types Shapio's schema always defines. Compared case-folded, so a model
+* called `string` (type `String`) or `pageInfo` is rejected.
+*/
+const RESERVED_TYPE_NAMES = [
+	"Query",
+	"Mutation",
+	"Subscription",
+	"String",
+	"Int",
+	"Float",
+	"Boolean",
+	"ID",
+	"JSON",
+	"Date",
+	"DateTime",
+	"Time",
+	"Decimal",
+	"BigInt",
+	"RichText",
+	"Media",
+	"MediaAsset",
+	"MediaVariant",
+	"FocalPoint",
+	"MediaKind",
+	"Int53",
+	"PageInfo",
+	"Locale",
+	"PublicationState",
+	"SortDirection",
+	"Node",
+	"Entry",
+	"Upload",
+	"StringFilter",
+	"IntFilter",
+	"FloatFilter",
+	"BooleanFilter",
+	"IDFilter",
+	"DateFilter",
+	"DateTimeFilter",
+	"TimeFilter",
+	"DecimalFilter",
+	"BigIntFilter",
+	"JSONFilter",
+	"SnapshotChange",
+	"SnapshotChangeKind",
+	"SnapshotChangeLocale",
+	"SnapshotChangePage",
+	"SnapshotInfo"
+];
+/**
+* Model and component API keys the admin uses as static URL segments (`/content/new`,
+* `/develop/components`), so a type with one of these keys could not be opened. Compared case-folded.
+*/
+const RESERVED_DEFINITION_API_KEYS = ["new", "components"];
+/**
+* Field API keys that collide with the system fields every entry exposes in REST and GraphQL.
+* Compared case-folded.
+*/
+const RESERVED_FIELD_API_KEYS = [
+	"id",
+	"locale",
+	"localizations",
+	"status",
+	"version",
+	"createdAt",
+	"updatedAt",
+	"publishedAt",
+	"createdBy",
+	"updatedBy",
+	"publicationState",
+	"and",
+	"or",
+	"not"
+];
+/**
+* Root query fields every GraphQL schema has, whatever models exist. Compared case-folded. The first is the
+* schema version field (schemaBuilder.ts reads it by position).
+*/
+const RESERVED_QUERY_NAMES = [
+	"_schemaVersion",
+	"_changes",
+	"_snapshot"
+];
+/** Every name a definition contributes to the GraphQL schema. */
+const generatedNames = (definition) => {
+	const typeName = toTypeName(definition.apiKey);
+	const definitionId = definition.id;
+	const names = (definition.kind === "component" ? COMPONENT_TYPE_SUFFIXES : MODEL_TYPE_SUFFIXES).map((suffix) => ({
+		namespace: "type",
+		name: `${typeName}${suffix}`,
+		definitionId
+	}));
+	for (const field of definition.fields) {
+		const fieldType = `${typeName}${toTypeName(field.apiKey)}`;
+		if (field.type === "enum") names.push({
+			namespace: "type",
+			name: `${fieldType}Enum`,
+			definitionId,
+			fieldId: field.id
+		});
+		if (field.type === "dynamiczone") {
+			names.push({
+				namespace: "type",
+				name: `${fieldType}Zone`,
+				definitionId,
+				fieldId: field.id
+			});
+			names.push({
+				namespace: "type",
+				name: `${fieldType}ZoneInput`,
+				definitionId,
+				fieldId: field.id
+			});
+		}
+	}
+	if (definition.kind !== "component") {
+		names.push({
+			namespace: "query",
+			name: definition.apiKey,
+			definitionId
+		});
+		if (definition.kind === "collection") names.push({
+			namespace: "query",
+			name: collectionQueryName(definition),
+			definitionId,
+			property: "pluralApiKey"
+		});
+		for (const prefix of MUTATION_PREFIXES) names.push({
+			namespace: "mutation",
+			name: `${prefix}${typeName}`,
+			definitionId
+		});
+	}
+	return names;
+};
+//#endregion
+//#region src/validators/typeboxIssues.ts
+/**
+* TypeBox errors as (JSON pointer, message) pairs. The `schema is false` echo that accompanies every
+* `additionalProperties` error is dropped, and unknown properties are named in the message.
+*/
+const collectSchemaErrors = (schema, value, basePath = "") => [...Value.Errors(schema, value)].filter((error) => error.keyword !== "boolean").map((error) => {
+	const extra = error.params.additionalProperties;
+	const message = error.keyword === "additionalProperties" && Array.isArray(extra) ? `unknown propert${extra.length === 1 ? "y" : "ies"}: ${extra.join(", ")}` : error.message;
+	return {
+		path: `${basePath}${error.instancePath}`,
+		message
+	};
+});
+//#endregion
+//#region src/validators/definition.ts
+/**
+* Checks one normalized definition on its own: IDs, API keys, per-type settings, flags, editor choice and
+* display references. References to other definitions are checked by `validateSchema`.
+*/
+const RESERVED_FIELD_KEYS = new Set(RESERVED_FIELD_API_KEYS.map(foldApiKey));
+const RESERVED_DEFINITION_KEYS = new Set(RESERVED_DEFINITION_API_KEYS.map(foldApiKey));
+/** GraphQL enum values must be names and cannot be `true`, `false` or `null`. */
+const RESERVED_ENUM_VALUES = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null"
+]);
+const compareNumbers = (a, b) => a - b;
+const compareBigInts = (a, b) => {
+	const diff = BigInt(a) - BigInt(b);
+	return diff === 0n ? 0 : diff > 0n ? 1 : -1;
+};
+const compareDecimals = (a, b) => Number(a) - Number(b);
+const compareText = (a, b) => a === b ? 0 : a > b ? 1 : -1;
+const checkRange = ({ min, max, compare, path }) => min !== void 0 && max !== void 0 && compare(min, max) > 0 ? [issue(path, "INVALID_RANGE", "minimum is greater than maximum")] : [];
+const settingsRanges = (field, path) => {
+	const s = field.settings;
+	const issues = [];
+	issues.push(...checkRange({
+		min: s.minLength,
+		max: s.maxLength,
+		compare: compareNumbers,
+		path: `${path}/minLength`
+	}));
+	switch (field.type) {
+		case "number":
+		case "integer":
+		case "media":
+		case "relation":
+		case "component":
+		case "dynamiczone":
+			issues.push(...checkRange({
+				min: s.min,
+				max: s.max,
+				compare: compareNumbers,
+				path: `${path}/min`
+			}));
+			break;
+		case "biginteger":
+			issues.push(...checkRange({
+				min: s.min,
+				max: s.max,
+				compare: compareBigInts,
+				path: `${path}/min`
+			}));
+			break;
+		case "decimal":
+			issues.push(...checkRange({
+				min: s.min,
+				max: s.max,
+				compare: compareDecimals,
+				path: `${path}/min`
+			}));
+			if (field.settings.scale !== void 0 && field.settings.precision !== void 0) issues.push(...checkRange({
+				min: field.settings.scale,
+				max: field.settings.precision,
+				compare: compareNumbers,
+				path: `${path}/scale`
+			}));
+			break;
+		case "date":
+		case "datetime":
+		case "time": issues.push(...checkRange({
+			min: s.min,
+			max: s.max,
+			compare: compareText,
+			path: `${path}/min`
+		}));
+	}
+	return issues;
+};
+const checkSettings = (field, path, definition) => {
+	const issues = settingsRanges(field, `${path}/settings`);
+	if (field.type === "string" && field.settings.pattern !== void 0) try {
+		new RegExp(field.settings.pattern, "u");
+	} catch {
+		issues.push(issue(`${path}/settings/pattern`, "INVALID_PATTERN", "is not a valid regular expression"));
+	}
+	if (field.type === "enum") {
+		const seen = /* @__PURE__ */ new Set();
+		field.settings.values.forEach((entry, index) => {
+			const entryPath = `${path}/settings/values/${index}/value`;
+			if (!isApiKeySyntaxValid(entry.value) || entry.value.startsWith("__") || RESERVED_ENUM_VALUES.has(entry.value)) issues.push(issue(entryPath, "INVALID_ENUM_VALUE", "enum values must be GraphQL names (letters, digits, _), not true/false/null"));
+			if (seen.has(entry.value)) issues.push(issue(entryPath, "DUPLICATE_ENUM_VALUE", `"${entry.value}" is listed twice`));
+			seen.add(entry.value);
+		});
+	}
+	if (field.type === "slug" && field.settings.sourceFieldId !== void 0) {
+		const source = definition.fields.find((candidate) => candidate.id === field.settings.sourceFieldId);
+		if (!source) issues.push(issue(`${path}/settings/sourceFieldId`, "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition"));
+		else if (source.type !== "string" && source.type !== "text") issues.push(issue(`${path}/settings/sourceFieldId`, "INVALID_FIELD_REFERENCE", "must refer to a string or text field"));
+	}
+	if (field.type === "richtext" && field.settings.formatVersion !== 1) issues.push(issue(`${path}/settings/formatVersion`, "INVALID_SETTINGS", "unsupported rich-text format version"));
+	if (field.type === "relation" && !isStableId(field.settings.target)) issues.push(issue(`${path}/settings/target`, "INVALID_ID", "must be the ID of a model"));
+	if (field.type === "component" && !isStableId(field.settings.component)) issues.push(issue(`${path}/settings/component`, "INVALID_ID", "must be the ID of a component"));
+	if (field.type === "dynamiczone") field.settings.components.forEach((id, index) => {
+		if (!isStableId(id)) issues.push(issue(`${path}/settings/components/${index}`, "INVALID_ID", "must be the ID of a component"));
+	});
+	return issues;
+};
+const checkFlags = (field, path, isComponent) => {
+	const issues = [];
+	const reject = (flag, why) => issues.push(issue(`${path}/${flag}`, "UNSUPPORTED_FLAG", why));
+	if (field.unique && !UNIQUE_CAPABLE_DATA_TYPES.has(field.type)) reject("unique", `${field.type} fields cannot be unique`);
+	for (const flag of ["filterable", "sortable"]) {
+		if (field[flag] && !SCALAR_DATA_TYPES.has(field.type)) reject(flag, `${field.type} fields cannot be ${flag}`);
+		if (field[flag] && field.type === "enum" && field.settings.multiple) reject(flag, `multi-value enum fields cannot be ${flag}`);
+	}
+	if (isComponent) {
+		for (const flag of [
+			"unique",
+			"filterable",
+			"sortable"
+		]) if (field[flag]) reject(flag, `fields of a component cannot be ${flag}`);
+	}
+	if (field.deprecated && field.required) reject("required", "a deprecated field cannot be required");
+	return issues;
+};
+const checkEditor = (field, path) => {
+	const { id, options } = field.editor;
+	if (isCustomEditorId(id)) return [];
+	const entry = EDITOR_CATALOGUE.get(id);
+	if (!entry) return [issue(`${path}/editor/id`, "UNKNOWN_EDITOR", `"${id}" is not a built-in editor (custom editors use a vendor.name ID)`)];
+	if (!entry.dataTypes.includes(field.type) || !(entry.supports?.(field) ?? true)) return [issue(`${path}/editor/id`, "INCOMPATIBLE_EDITOR", `the ${id} editor cannot edit this ${field.type} field`)];
+	return collectSchemaErrors(entry.optionsSchema, options, `${path}/editor/options`).map((error) => issue(error.path, "INVALID_EDITOR_OPTIONS", error.message));
+};
+const checkField = (field, index, definition) => {
+	const path = `/fields/${index}`;
+	const issues = [];
+	if (!isStableId(field.id)) issues.push(issue(`${path}/id`, "INVALID_ID", "must be a lower-case UUID"));
+	const syntax = checkApiKeySyntax(field.apiKey);
+	if (syntax) issues.push(issue(`${path}/apiKey`, syntax.code, syntax.message));
+	else if (RESERVED_FIELD_KEYS.has(foldApiKey(field.apiKey))) issues.push(issue(`${path}/apiKey`, "API_KEY_RESERVED", `"${field.apiKey}" is a system field name`));
+	issues.push(...checkSettings(field, path, definition));
+	issues.push(...checkFlags(field, path, definition.kind === "component"));
+	const defaultProblem = checkDefaultValue(field);
+	if (defaultProblem) issues.push(issue(`${path}/defaultValue`, "INVALID_DEFAULT_VALUE", defaultProblem));
+	issues.push(...checkEditor(field, path));
+	return issues;
+};
+const checkFieldUniqueness = (definition) => {
+	const issues = [];
+	const ids = /* @__PURE__ */ new Set();
+	const keys = /* @__PURE__ */ new Map();
+	definition.fields.forEach((field, index) => {
+		if (ids.has(field.id)) issues.push(issue(`/fields/${index}/id`, "DUPLICATE_ID", "another field has the same ID"));
+		ids.add(field.id);
+		const folded = foldApiKey(field.apiKey);
+		const clash = keys.get(folded);
+		if (clash !== void 0) issues.push(issue(`/fields/${index}/apiKey`, "API_KEY_COLLISION", `"${field.apiKey}" collides with field "${clash}" (keys are case-insensitive)`));
+		keys.set(folded, field.apiKey);
+	});
+	return issues;
+};
+const checkGroups = (groups, fieldIds) => {
+	const issues = [];
+	const groupIds = /* @__PURE__ */ new Set();
+	const placed = /* @__PURE__ */ new Set();
+	(groups ?? []).forEach((group, groupIndex) => {
+		if (groupIds.has(group.id)) issues.push(issue(`/display/groups/${groupIndex}/id`, "DUPLICATE_GROUP", "another group has the same ID"));
+		groupIds.add(group.id);
+		group.fieldIds.forEach((fieldId, index) => {
+			const path = `/display/groups/${groupIndex}/fieldIds/${index}`;
+			if (!fieldIds.has(fieldId)) issues.push(issue(path, "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition"));
+			else if (placed.has(fieldId)) issues.push(issue(path, "INVALID_FIELD_REFERENCE", "a field can be in one group only"));
+			placed.add(fieldId);
+		});
+	});
+	return issues;
+};
+/** A list of field IDs: each must exist, appear once and pass `reject`. */
+const checkFieldList = (ids, check) => {
+	const seen = /* @__PURE__ */ new Set();
+	return (ids ?? []).flatMap((fieldId, index) => {
+		const path = `${check.path}/${index}`;
+		const field = check.fields.get(fieldId);
+		if (!field) return [issue(path, "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition")];
+		if (seen.has(fieldId)) return [issue(path, "INVALID_FIELD_REFERENCE", "the field is listed more than once")];
+		seen.add(fieldId);
+		const reason = check.reject(field);
+		return reason ? [issue(path, "INVALID_FIELD_REFERENCE", reason)] : [];
+	});
+};
+/**
+* The entry document's layout (`effectiveLayout`): canvas blocks, cover and strip. Title, cover and canvas
+* are disjoint (title types are never canvas or cover types, so eligibility covers the title); strip
+* entries are properties, so never the cover or a canvas block.
+*/
+const checkDocumentLayout = (model, fields) => {
+	const { canvasFieldIds, coverFieldId, stripFieldIds } = model.display;
+	const canvas = new Set(canvasFieldIds ?? []);
+	const issues = checkFieldList(canvasFieldIds, {
+		path: "/display/canvasFieldIds",
+		fields,
+		reject: (field) => isCanvasEligible(field) ? void 0 : canvasRejection(field)
+	});
+	if (coverFieldId !== void 0) issues.push(...checkFieldList([coverFieldId], {
+		path: "/display/coverFieldId",
+		fields,
+		reject: (field) => !isCoverEligible(field) ? "the cover must be a single media field that allows images" : canvas.has(field.id) ? "the cover cannot also be in the canvas" : void 0
+	}).map((found) => ({
+		...found,
+		path: "/display/coverFieldId"
+	})));
+	issues.push(...checkFieldList(stripFieldIds, {
+		path: "/display/stripFieldIds",
+		fields,
+		reject: (field) => canvas.has(field.id) || field.id === coverFieldId ? "the strip shows properties, not the cover or canvas blocks" : void 0
+	}));
+	return issues;
+};
+const canvasRejection = (field) => {
+	if (field.type === "component") return "only a repeatable component can be in the canvas";
+	if (field.type === "media") return "only a media field with several files can be in the canvas";
+	return `a ${field.type} field cannot be in the canvas`;
+};
+const checkDisplay = (definition) => {
+	const fields = new Map(definition.fields.map((field) => [field.id, field]));
+	const fieldIds = new Set(fields.keys());
+	const issues = [];
+	const { titleFieldId } = definition.display;
+	if (titleFieldId !== void 0) {
+		const title = fields.get(titleFieldId);
+		if (!title) issues.push(issue("/display/titleFieldId", "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition"));
+		else if (!TITLE_FIELD_TYPES.has(title.type)) issues.push(issue("/display/titleFieldId", "INVALID_FIELD_REFERENCE", `a ${title.type} field cannot be the title`));
+	}
+	if (definition.kind !== "component") {
+		definition.display.listFieldIds?.forEach((fieldId, index) => {
+			if (!fieldIds.has(fieldId)) issues.push(issue(`/display/listFieldIds/${index}`, "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition"));
+		});
+		const sort = definition.display.defaultSort;
+		if (sort) {
+			const field = fields.get(sort.fieldId);
+			if (!field) issues.push(issue("/display/defaultSort/fieldId", "UNKNOWN_FIELD_REFERENCE", "refers to no field of this definition"));
+			else if (!field.sortable) issues.push(issue("/display/defaultSort/fieldId", "INVALID_FIELD_REFERENCE", "the default sort field must be sortable"));
+		}
+		issues.push(...checkDocumentLayout(definition, fields));
+	}
+	issues.push(...checkGroups(definition.display.groups, fieldIds));
+	return issues;
+};
+/**
+* A collection's plural API ID follows the API ID rules and must differ from its singular. Singletons and
+* components have none (normalizing drops it).
+*/
+const checkPluralApiKey = (definition) => {
+	if (definition.kind !== "collection" || definition.pluralApiKey === void 0) return [];
+	const syntax = checkApiKeySyntax(definition.pluralApiKey, "plural API ID");
+	if (syntax) return [issue("/pluralApiKey", syntax.code, syntax.message)];
+	if (foldApiKey(definition.pluralApiKey) === foldApiKey(definition.apiKey)) return [issue("/pluralApiKey", "PLURAL_API_KEY_SAME_AS_SINGULAR", "the plural API ID must differ from the API ID (case-insensitively)")];
+	return [];
+};
+/** All problems with one definition, in document order. Empty means valid on its own. */
+const validateDefinition = (definition) => {
+	const issues = [];
+	if (!isStableId(definition.id)) issues.push(issue("/id", "INVALID_ID", "must be a lower-case UUID"));
+	const syntax = checkApiKeySyntax(definition.apiKey);
+	if (syntax) issues.push(issue("/apiKey", syntax.code, syntax.message));
+	else if (RESERVED_DEFINITION_KEYS.has(foldApiKey(definition.apiKey))) issues.push(issue("/apiKey", "API_KEY_RESERVED", `"${definition.apiKey}" is reserved by the admin`));
+	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));
+	return issues;
+};
+//#endregion
+//#region src/validators/parse.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const structuralIssues = (raw) => {
+	const schema = raw.kind === "component" ? ComponentDefinitionInputSchema : ModelDefinitionInputSchema;
+	const issues = collectSchemaErrors(schema, raw).map((error) => issue(error.path, "INVALID_STRUCTURE", error.message));
+	if (issues.length > 0) return issues;
+	raw.fields.forEach((field, index) => {
+		const settingsSchema = SETTINGS_SCHEMAS[field.type];
+		for (const error of collectSchemaErrors(settingsSchema, field.settings ?? {}, `/fields/${index}/settings`)) issues.push(issue(error.path, "INVALID_SETTINGS", error.message));
+	});
+	return issues;
+};
+/** Fills in missing definition and field IDs (see ParseDefinitionOptions.previous). */
+const assignIds = (input, { previous, createId = createStableId } = {}) => {
+	const explicitIds = new Set(input.fields.flatMap((field) => field.id ? [field.id] : []));
+	const previousByKey = new Map((previous?.fields ?? []).filter((field) => !explicitIds.has(field.id)).map((field) => [foldApiKey(field.apiKey), field.id]));
+	const fields = input.fields.map((field) => {
+		if (field.id) return {
+			...field,
+			id: field.id
+		};
+		const matched = previousByKey.get(foldApiKey(field.apiKey));
+		previousByKey.delete(foldApiKey(field.apiKey));
+		return {
+			...field,
+			id: matched ?? createId()
+		};
+	});
+	return {
+		...input,
+		id: input.id ?? previous?.id ?? createId(),
+		fields
+	};
+};
+/**
+* The single entry point from untrusted input (request bodies, schema files) to a normalized definition:
+* structure, settings per data type, ID assignment, defaults, then the per-definition semantic checks.
+* Cross-definition rules (references, cycles, GraphQL name collisions) are `validateSchema`'s job.
+*/
+const parseDefinition = (raw, options = {}) => {
+	if (!isObject(raw)) return {
+		ok: false,
+		issues: [issue("", "INVALID_STRUCTURE", "a definition must be a JSON object")]
+	};
+	const structural = structuralIssues(raw);
+	if (structural.length > 0) return {
+		ok: false,
+		issues: structural
+	};
+	const definition = normalizeDefinition(assignIds(raw, options));
+	const issues = validateDefinition(definition);
+	return issues.length > 0 ? {
+		ok: false,
+		issues
+	} : {
+		ok: true,
+		definition
+	};
+};
+//#endregion
+//#region src/validators/schema.ts
+/** Deepest allowed nesting of components (a component inside a component inside ... ) below an entry. */
+const MAX_COMPONENT_DEPTH = 5;
+const RESERVED_TYPES = new Set(RESERVED_TYPE_NAMES.map(foldApiKey));
+const RESERVED_QUERIES = new Set(RESERVED_QUERY_NAMES.map(foldApiKey));
+const withDefinition = (definition, found) => ({
+	...found,
+	definitionId: definition.id
+});
+const describeOrigin = (name, byId) => {
+	const definition = byId.get(name.definitionId);
+	const field = name.fieldId ? definition?.fields.find((candidate) => candidate.id === name.fieldId) : void 0;
+	return field ? `${definition?.apiKey ?? "?"}.${field.apiKey}` : definition?.apiKey ?? "?";
+};
+/** The API IDs a definition claims in the shared case-insensitive namespace, with their issue paths. */
+const claimedKeys = (definition) => {
+	const keys = [{
+		key: definition.apiKey,
+		path: "/apiKey",
+		plural: false
+	}];
+	const plural = definition.kind === "collection" ? routeKeyOf(definition) : "";
+	if (plural) keys.push({
+		key: plural,
+		path: "/pluralApiKey",
+		plural: true
+	});
+	return keys;
+};
+const describeKey = ({ definition, key }) => key === definition.apiKey ? `"${key}"` : `the plural API ID "${key}" of "${definition.apiKey}"`;
+const checkIdentity = (definitions) => {
+	const issues = [];
+	const ids = /* @__PURE__ */ new Set();
+	const keys = /* @__PURE__ */ new Map();
+	const fieldOwners = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		if (ids.has(definition.id)) issues.push(withDefinition(definition, issue("/id", "DUPLICATE_ID", "another definition has the same ID")));
+		ids.add(definition.id);
+		for (const { key, path, plural } of claimedKeys(definition)) {
+			const folded = foldApiKey(key);
+			const clash = keys.get(folded);
+			if (clash && clash.definition.id !== definition.id) issues.push(withDefinition(definition, issue(path, "API_KEY_COLLISION", `${plural ? "the plural API ID " : ""}"${key}" collides with ${describeKey(clash)} (models and components share one case-insensitive namespace)`)));
+			if (!clash) keys.set(folded, {
+				definition,
+				key
+			});
+		}
+		definition.fields.forEach((field, index) => {
+			const owner = fieldOwners.get(field.id);
+			if (owner && owner.id !== definition.id) issues.push(withDefinition(definition, issue(`/fields/${index}/id`, "DUPLICATE_ID", `field ID is already used by "${owner.apiKey}"; field IDs are global`)));
+			fieldOwners.set(field.id, definition);
+		});
+	}
+	return issues;
+};
+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 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))) {
+			issues.push(withDefinition(definition, issue(path, "API_KEY_RESERVED", `generates the GraphQL type "${name.name}", which is reserved`)));
+			continue;
+		}
+		if (name.namespace === "query" && RESERVED_QUERIES.has(foldApiKey(name.name))) {
+			issues.push(withDefinition(definition, issue(path, "API_KEY_RESERVED", `generates the GraphQL query "${name.name}", which is reserved`)));
+			continue;
+		}
+		const clash = seen.get(folded);
+		if (clash && (clash.definitionId !== name.definitionId || clash.fieldId !== name.fieldId)) {
+			issues.push(withDefinition(definition, issue(path, "GENERATED_NAME_COLLISION", `generates the GraphQL ${name.namespace} name "${name.name}", which "${describeOrigin(clash, byId)}" already generates`)));
+			continue;
+		}
+		seen.set(folded, name);
+	}
+	return issues;
+};
+/** Component IDs a definition embeds directly (component and dynamic-zone fields). */
+const embeddedComponentIds = (definition) => definition.fields.flatMap((field) => {
+	if (field.type === "component") return [field.settings.component];
+	if (field.type === "dynamiczone") return field.settings.components;
+	return [];
+});
+const checkReferences = (definitions) => {
+	const byId = new Map(definitions.map((definition) => [definition.id, definition]));
+	const issues = [];
+	for (const definition of definitions) definition.fields.forEach((field, index) => {
+		const path = `/fields/${index}/settings`;
+		const expectComponent = (id, at) => {
+			const target = byId.get(id);
+			if (!target) issues.push(withDefinition(definition, issue(at, "UNKNOWN_REFERENCE", "refers to no component")));
+			else if (target.kind !== "component") issues.push(withDefinition(definition, issue(at, "INVALID_REFERENCE_TARGET", `"${target.apiKey}" is a model, not a component`)));
+		};
+		if (field.type === "relation") {
+			const target = byId.get(field.settings.target);
+			if (!target) issues.push(withDefinition(definition, issue(`${path}/target`, "UNKNOWN_REFERENCE", "refers to no model")));
+			else if (target.kind !== "collection") issues.push(withDefinition(definition, issue(`${path}/target`, "INVALID_REFERENCE_TARGET", `relations must target a collection model; "${target.apiKey}" is a ${target.kind}`)));
+		}
+		if (field.type === "component") expectComponent(field.settings.component, `${path}/component`);
+		if (field.type === "dynamiczone") {
+			const seen = /* @__PURE__ */ new Set();
+			field.settings.components.forEach((id, componentIndex) => {
+				const at = `${path}/components/${componentIndex}`;
+				if (seen.has(id)) issues.push(withDefinition(definition, issue(at, "DUPLICATE_ID", "component listed twice")));
+				seen.add(id);
+				expectComponent(id, at);
+			});
+		}
+	});
+	return issues;
+};
+/**
+* Longest chain of nested components below each definition, or a cycle. Depth 1 means the definition
+* embeds components that embed nothing.
+*/
+const checkNesting = (definitions) => {
+	const byId = new Map(definitions.map((definition) => [definition.id, definition]));
+	const depthOf = /* @__PURE__ */ new Map();
+	const issues = [];
+	const reported = /* @__PURE__ */ new Set();
+	const visit = (id, stack) => {
+		const known = depthOf.get(id);
+		if (known !== void 0) return known;
+		if (stack.includes(id)) {
+			const cycle = [...stack.slice(stack.indexOf(id)), id].map((member) => byId.get(member)?.apiKey ?? member);
+			const definition = byId.get(id);
+			if (definition && !reported.has(id)) {
+				reported.add(id);
+				issues.push(withDefinition(definition, issue("/fields", "COMPONENT_CYCLE", `components nest in a cycle: ${cycle.join(" → ")}`)));
+			}
+			return Number.POSITIVE_INFINITY;
+		}
+		const definition = byId.get(id);
+		if (!definition) return 0;
+		const children = embeddedComponentIds(definition).filter((child) => byId.get(child)?.kind === "component");
+		const depth = children.length === 0 ? 0 : 1 + Math.max(...children.map((child) => visit(child, [...stack, id])));
+		depthOf.set(id, depth);
+		return depth;
+	};
+	for (const definition of definitions) {
+		const depth = visit(definition.id, []);
+		if (Number.isFinite(depth) && depth > 5 && definition.kind !== "component") issues.push(withDefinition(definition, issue("/fields", "COMPONENT_TOO_DEEP", `components nest ${depth} levels deep; the limit is 5`)));
+	}
+	return issues;
+};
+/**
+* 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`.
+*/
+const validateSchema = (definitions) => [
+	...checkIdentity(definitions),
+	...checkGeneratedNames(definitions),
+	...checkReferences(definitions),
+	...checkNesting(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").
+*/
+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 models = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [componentId];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		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);
+	}
+	return [...models.values()];
+};
+//#endregion
+//#region src/diff/types.ts
+const CHANGE_KINDS = [
+	"definition.added",
+	"definition.removed",
+	"definition.apiKey",
+	"definition.pluralApiKey",
+	"definition.metadata",
+	"model.kind",
+	"model.localized",
+	"model.draftAndPublish",
+	"field.added",
+	"field.removed",
+	"field.order",
+	"field.apiKey",
+	"field.metadata",
+	"field.editor",
+	"field.type",
+	"field.required",
+	"field.localized",
+	"field.public",
+	"field.deprecated",
+	"field.unique",
+	"field.filterable",
+	"field.sortable",
+	"field.settings"
+];
+//#endregion
+//#region src/fileFormat/canonical.ts
+/**
+* Canonical JSON: object keys sorted by code point at every level, arrays in their given order (field
+* order is meaningful: it is the form order), two-space indentation and a trailing newline. Two equal
+* definitions always serialize to the same bytes, so files diff cleanly in git and hashes are stable.
+*/
+const sortKeys = (value) => {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value === "object" && value !== null) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) {
+			const entry = value[key];
+			if (entry !== void 0) sorted[key] = sortKeys(entry);
+		}
+		return sorted;
+	}
+	return value;
+};
+const canonicalJson = (value) => `${JSON.stringify(sortKeys(value), null, 2)}\n`;
+/**
+* The bytes Shapio hashes and writes for a definition. The definition must be normalized
+* (`normalizeDefinition`), so defaults are explicit and the same meaning has one spelling.
+*/
+const serializeDefinition = (definition) => canonicalJson(definition);
+//#endregion
+//#region src/diff/diffDefinitions.ts
+const same = (a, b) => canonicalJson(a ?? null) === canonicalJson(b ?? null);
+const asJson = (value) => value;
+const DEFINITION_METADATA = [
+	"label",
+	"description",
+	"category",
+	"icon",
+	"display"
+];
+const FIELD_METADATA = [
+	"label",
+	"description",
+	"defaultValue"
+];
+const FIELD_FLAGS = [
+	["required", "field.required"],
+	["localized", "field.localized"],
+	["public", "field.public"],
+	["deprecated", "field.deprecated"],
+	["unique", "field.unique"],
+	["filterable", "field.filterable"],
+	["sortable", "field.sortable"]
+];
+const diffFieldSettings = (definitionId, before, after) => {
+	const from = before.settings;
+	const to = after.settings;
+	return [.../* @__PURE__ */ new Set([...Object.keys(from), ...Object.keys(to)])].sort().filter((key) => !same(from[key], to[key])).map((key) => ({
+		kind: "field.settings",
+		definitionId,
+		fieldId: after.id,
+		property: key,
+		from: asJson(from[key]),
+		to: asJson(to[key])
+	}));
+};
+const diffField = (definitionId, before, after) => {
+	const changes = [];
+	const base = {
+		definitionId,
+		fieldId: after.id
+	};
+	if (before.apiKey !== after.apiKey) changes.push({
+		...base,
+		kind: "field.apiKey",
+		from: before.apiKey,
+		to: after.apiKey
+	});
+	for (const property of FIELD_METADATA) if (!same(before[property], after[property])) changes.push({
+		...base,
+		kind: "field.metadata",
+		property,
+		from: asJson(before[property]),
+		to: asJson(after[property])
+	});
+	if (!same(before.editor, after.editor)) changes.push({
+		...base,
+		kind: "field.editor",
+		from: before.editor,
+		to: after.editor
+	});
+	if (before.type !== after.type) changes.push({
+		...base,
+		kind: "field.type",
+		from: before.type,
+		to: after.type
+	});
+	else changes.push(...diffFieldSettings(definitionId, before, after));
+	for (const [flag, kind] of FIELD_FLAGS) if (before[flag] !== after[flag]) changes.push({
+		...base,
+		kind,
+		from: before[flag],
+		to: after[flag]
+	});
+	return changes;
+};
+/**
+* Every difference between two versions of a definition, matched by stable IDs (so a renamed field is a
+* rename, not a removal plus an addition). Pass `null` for a side that does not exist. The order is
+* deterministic: definition-level changes, then fields in the new order, then removed fields.
+*/
+const diffDefinitions = (before, after) => {
+	if (!before && !after) return [];
+	if (!before) return [{
+		kind: "definition.added",
+		definitionId: after.id,
+		to: after.apiKey
+	}];
+	if (!after) return [{
+		kind: "definition.removed",
+		definitionId: before.id,
+		from: before.apiKey
+	}];
+	const definitionId = after.id;
+	const changes = [];
+	if (before.apiKey !== after.apiKey) changes.push({
+		kind: "definition.apiKey",
+		definitionId,
+		from: before.apiKey,
+		to: after.apiKey
+	});
+	const beforeRecord = before;
+	const afterRecord = after;
+	for (const property of DEFINITION_METADATA) if (!same(beforeRecord[property], afterRecord[property])) changes.push({
+		kind: "definition.metadata",
+		definitionId,
+		property,
+		from: asJson(beforeRecord[property]),
+		to: asJson(afterRecord[property])
+	});
+	if (before.kind !== after.kind) changes.push({
+		kind: "model.kind",
+		definitionId,
+		from: before.kind,
+		to: after.kind
+	});
+	if (before.kind === "collection" && after.kind === "collection") {
+		const [from, to] = [routeKeyOf(before), routeKeyOf(after)];
+		if (from !== to) changes.push({
+			kind: "definition.pluralApiKey",
+			definitionId,
+			from,
+			to
+		});
+	}
+	if (before.kind !== "component" && after.kind !== "component") {
+		if (before.localized !== after.localized) changes.push({
+			kind: "model.localized",
+			definitionId,
+			from: before.localized,
+			to: after.localized
+		});
+		if (before.draftAndPublish !== after.draftAndPublish) changes.push({
+			kind: "model.draftAndPublish",
+			definitionId,
+			from: before.draftAndPublish,
+			to: after.draftAndPublish
+		});
+	}
+	const beforeFields = new Map(before.fields.map((field) => [field.id, field]));
+	const afterIds = new Set(after.fields.map((field) => field.id));
+	for (const field of after.fields) {
+		const previous = beforeFields.get(field.id);
+		if (!previous) changes.push({
+			kind: "field.added",
+			definitionId,
+			fieldId: field.id,
+			to: field
+		});
+		else changes.push(...diffField(definitionId, previous, field));
+	}
+	for (const field of before.fields) if (!afterIds.has(field.id)) changes.push({
+		kind: "field.removed",
+		definitionId,
+		fieldId: field.id,
+		from: field
+	});
+	const keptBefore = before.fields.filter((field) => afterIds.has(field.id)).map((field) => field.id);
+	const keptAfter = after.fields.filter((field) => beforeFields.has(field.id)).map((field) => field.id);
+	if (!same(keptBefore, keptAfter)) changes.push({
+		kind: "field.order",
+		definitionId,
+		from: keptBefore,
+		to: keptAfter
+	});
+	return changes;
+};
+//#endregion
+//#region src/diff/classify.ts
+const result = (category, extra = {}) => ({
+	category,
+	breaking: false,
+	destructive: false,
+	supported: true,
+	prerequisites: [],
+	cleanup: [],
+	...extra
+});
+const findField = (definition, fieldId) => definition?.fields.find((field) => field.id === fieldId);
+const hasIndex = (field) => Boolean(field && (field.filterable || field.sortable));
+/** Names delivery APIs use for a type; a change of name is a contract change. */
+const API_SCALAR = {
+	string: "String",
+	text: "String",
+	slug: "String",
+	email: "String",
+	url: "String",
+	uid: "String",
+	enum: "Enum",
+	date: "Date",
+	datetime: "DateTime",
+	time: "Time",
+	number: "Float",
+	integer: "Int",
+	decimal: "Decimal",
+	biginteger: "BigInt",
+	boolean: "Boolean",
+	json: "JSON",
+	richtext: "RichText",
+	media: "Media",
+	relation: "Relation",
+	component: "Component",
+	dynamiczone: "DynamicZone"
+};
+const PLAIN_TEXT_TYPES = /* @__PURE__ */ new Set(["string", "text"]);
+const SCALAR_FAMILIES = /* @__PURE__ */ new Set([
+	"jsonString",
+	"jsonNumber",
+	"numericString",
+	"boolean"
+]);
+const hasTextConstraints = (field) => {
+	const settings = field?.settings ?? {};
+	return settings.minLength !== void 0 || settings.maxLength !== void 0 || settings.pattern !== void 0;
+};
+/**
+* A type change. Within one storage family the stored JSON stays as it is: widening is live, anything else
+* re-validates existing values. Across families Shapio converts values with a job, for the pairs it knows.
+*/
+const classifyTypeChange = (from, to, after) => {
+	const breaking = API_SCALAR[from] !== API_SCALAR[to];
+	const fromFamily = STORAGE_FAMILY[from];
+	const toFamily = STORAGE_FAMILY[to];
+	if (fromFamily === toFamily) return fromFamily === "jsonString" && PLAIN_TEXT_TYPES.has(to) && !hasTextConstraints(after) || from === "integer" && to === "number" || from === "biginteger" && to === "decimal" && after?.type === "decimal" && after.settings.precision === void 0 ? result("additive", { breaking }) : result("validation", {
+		breaking,
+		prerequisites: ["validateValues"]
+	});
+	const numericPair = fromFamily === "jsonNumber" && toFamily === "numericString" || fromFamily === "numericString" && toFamily === "jsonNumber";
+	const toText = SCALAR_FAMILIES.has(fromFamily) && PLAIN_TEXT_TYPES.has(to);
+	const textToRichtext = fromFamily === "jsonString" && to === "richtext";
+	const richtextToText = from === "richtext" && PLAIN_TEXT_TYPES.has(to);
+	const supported = numericPair || toText || textToRichtext || richtextToText;
+	return result("conversion", {
+		breaking,
+		supported,
+		destructive: richtextToText,
+		prerequisites: supported ? ["convert", "validateValues"] : []
+	});
+};
+const compareValues = (a, b) => {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	try {
+		const diff = BigInt(String(a)) - BigInt(String(b));
+		return diff === 0n ? 0 : diff > 0n ? 1 : -1;
+	} catch {
+		const numeric = Number(a) - Number(b);
+		return Number.isNaN(numeric) ? String(a).localeCompare(String(b)) : numeric;
+	}
+};
+/** A lower bound (min, minLength) that appears or rises, or an upper bound that appears or falls. */
+const isTightened = (bound, from, to) => {
+	if (to === void 0 || to === null) return false;
+	if (from === void 0 || from === null) return true;
+	const order = compareValues(from, to);
+	return bound === "lower" ? order < 0 : order > 0;
+};
+const asStrings = (value) => Array.isArray(value) ? value.map((entry) => typeof entry === "object" && entry !== null ? String(entry.value) : String(entry)) : [];
+const removesAny = (from, to) => {
+	const kept = new Set(asStrings(to));
+	return asStrings(from).some((entry) => !kept.has(entry));
+};
+const validation = (tightened) => tightened ? result("validation", { prerequisites: ["validateValues"] }) : result("additive");
+const classifySettingsChange = (change) => {
+	const { property, from, to } = change;
+	switch (property) {
+		case "minLength":
+		case "min": return validation(isTightened("lower", from, to));
+		case "maxLength":
+		case "max":
+		case "precision":
+		case "scale": return validation(isTightened("upper", from, to));
+		case "pattern": return validation(to !== void 0);
+		case "values": return validation(removesAny(from, to));
+		case "components":
+		case "allowedKinds":
+		case "protocols": return validation(to !== void 0 && (from === void 0 || removesAny(from, to)));
+		case "sourceFieldId": return result("metadata");
+		case "multiple":
+		case "repeatable":
+		case "cardinality": return result("conversion", {
+			breaking: true,
+			destructive: to === false || to === "one",
+			prerequisites: ["convert", "validateValues"]
+		});
+		case "formatVersion": return result("conversion", { prerequisites: ["convert", "validateValues"] });
+		case "target":
+		case "component": return result("conversion", {
+			breaking: true,
+			destructive: true,
+			prerequisites: ["convert"]
+		});
+		default: return result("validation", { prerequisites: ["validateValues"] });
+	}
+};
+const classifyFieldChange = (change, { before, after }) => {
+	const previous = findField(before, change.fieldId);
+	const field = findField(after, change.fieldId);
+	switch (change.kind) {
+		case "field.added": {
+			const prerequisites = [];
+			if (field?.required) prerequisites.push(field.defaultValue !== void 0 ? "backfill" : "validateRequired");
+			if (field?.unique) prerequisites.push("checkUnique");
+			if (hasIndex(field)) prerequisites.push("buildIndex");
+			return result(field?.required ? "requiredField" : "additive", { prerequisites });
+		}
+		case "field.removed": return result("removal", {
+			breaking: true,
+			cleanup: [...hasIndex(previous) ? ["dropIndex"] : [], ...previous?.unique ? ["releaseUnique"] : []]
+		});
+		case "field.order":
+		case "field.metadata": return result("metadata");
+		case "field.editor": return result("editorSwap");
+		case "field.apiKey": return result("contract", { breaking: true });
+		case "field.type": {
+			const classification = classifyTypeChange(change.from, change.to, field);
+			return field?.unique && previous?.unique && !classification.prerequisites.includes("checkUnique") ? {
+				...classification,
+				prerequisites: [...classification.prerequisites, "checkUnique"]
+			} : classification;
+		}
+		case "field.required":
+			if (change.to !== true) return result("additive");
+			return result("requiredField", { prerequisites: [field?.defaultValue !== void 0 ? "backfill" : "validateRequired"] });
+		case "field.localized":
+			if (!(after?.kind !== "component" && after?.localized === true)) return result("metadata");
+			return change.to === true ? result("additive") : result("conversion", {
+				destructive: true,
+				prerequisites: ["convert"]
+			});
+		case "field.public":
+		case "field.deprecated": {
+			const hides = change.kind === "field.public" ? change.to === false : change.to === true;
+			return result("metadata", { breaking: hides });
+		}
+		case "field.unique": return change.to === true ? result("constraint", { prerequisites: ["checkUnique"] }) : result("additive", { cleanup: ["releaseUnique"] });
+		case "field.filterable":
+		case "field.sortable":
+			if (hasIndex(field) && !hasIndex(previous)) return result("index", { prerequisites: ["buildIndex"] });
+			if (!hasIndex(field) && hasIndex(previous)) return result("index", { cleanup: ["dropIndex"] });
+			return result("metadata");
+		case "field.settings": return classifySettingsChange(change);
+		default: return result("metadata");
+	}
+};
+/** Classifies one change in the context of the definitions it was diffed from. */
+const classifyChange = (change, context) => {
+	let classification;
+	switch (change.kind) {
+		case "definition.added":
+			classification = result("additive");
+			break;
+		case "definition.removed":
+			classification = result("removal", { breaking: true });
+			break;
+		case "definition.apiKey":
+		case "definition.pluralApiKey":
+			classification = result("contract", { breaking: true });
+			break;
+		case "definition.metadata":
+			classification = result("metadata");
+			break;
+		case "model.kind":
+			classification = change.to === "singleton" ? result("validation", {
+				breaking: true,
+				prerequisites: ["validateValues"]
+			}) : result("contract", { breaking: true });
+			break;
+		case "model.localized":
+			classification = change.to === true ? result("additive") : result("conversion", {
+				destructive: true,
+				prerequisites: ["convert"]
+			});
+			break;
+		case "model.draftAndPublish":
+			classification = change.to === true ? result("additive") : result("conversion", {
+				destructive: true,
+				prerequisites: ["convert"]
+			});
+			break;
+		default: classification = classifyFieldChange(change, context);
+	}
+	return {
+		...change,
+		...classification
+	};
+};
+const classifyChanges = (changes, context) => changes.map((change) => classifyChange(change, context));
+const PREREQUISITE_ORDER = [
+	"convert",
+	"backfill",
+	"validateRequired",
+	"validateValues",
+	"checkUnique",
+	"buildIndex"
+];
+const summarizeChanges = (changes) => {
+	const prerequisites = new Set(changes.flatMap((change) => change.prerequisites));
+	return {
+		breaking: changes.some((change) => change.breaking),
+		destructive: changes.some((change) => change.destructive),
+		supported: changes.every((change) => change.supported),
+		prerequisites: PREREQUISITE_ORDER.filter((kind) => prerequisites.has(kind)),
+		cleanup: [...new Set(changes.flatMap((change) => change.cleanup))],
+		metadataOnly: changes.every((change) => change.category === "metadata" || change.category === "editorSwap")
+	};
+};
+/**
+* - added: live (entries gain the locale as editors fill it in);
+* - removed: destroys that locale's content (purged by a follow-up job), so it needs explicit consent;
+* - default changed: delivery falls back to a different locale, a contract change for API consumers;
+* - label or fallback chain: metadata.
+*/
+const classifyLocaleChange = (kind, code) => {
+	switch (kind) {
+		case "locale.added": return {
+			kind,
+			code,
+			category: "additive",
+			breaking: false,
+			destructive: false
+		};
+		case "locale.removed": return {
+			kind,
+			code,
+			category: "removal",
+			breaking: true,
+			destructive: true
+		};
+		case "locale.defaultChanged": return {
+			kind,
+			code,
+			category: "contract",
+			breaking: true,
+			destructive: false
+		};
+		default: return {
+			kind,
+			code,
+			category: "metadata",
+			breaking: false,
+			destructive: false
+		};
+	}
+};
+//#endregion
+//#region src/fileFormat/hash.ts
+const toHex = (buffer) => Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+/** `sha256:<hex>` of a UTF-8 string, via Web Crypto (Node and browsers alike). */
+const sha256 = async (text) => `sha256:${toHex(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)))}`;
+/** Hash of a normalized definition's canonical serialization; recorded per model in the lock file. */
+const hashDefinition = (definition) => sha256(serializeDefinition(definition));
+//#endregion
+//#region src/fileFormat/lockFile.ts
+/** Where `shapio schema pull` keeps its record of what it pulled, relative to the project root. */
+const LOCK_FILE_PATH = ".shapio/schema-lock.json";
+const LOCK_FILE_FORMAT_VERSION = 1;
+const LockEntrySchema = Type.Object({
+	kind: Type.Enum(DEFINITION_KINDS),
+	apiKey: Type.String(),
+	/** The definition's per-model version on the instance when it was pulled. */
+	version: Type.Integer({ minimum: 1 }),
+	/** `hashDefinition` of the pulled definition; a local file with another hash has been edited. */
+	hash: Type.String()
+}, { additionalProperties: false });
+const LockFileSchema = Type.Object({
+	formatVersion: Type.Literal(1),
+	/** The instance's global schema version at pull time (informational; the guard is per model). */
+	schemaVersion: Type.Integer({ minimum: 0 }),
+	/** Keyed by definition ID. */
+	definitions: Type.Record(Type.String(), LockEntrySchema)
+}, { additionalProperties: false });
+var LockFileError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LockFileError";
+	}
+};
+const parseLockFile = (text) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new LockFileError(`${LOCK_FILE_PATH} is not valid JSON`);
+	}
+	const errors = collectSchemaErrors(LockFileSchema, parsed);
+	if (errors.length > 0) throw new LockFileError(`${LOCK_FILE_PATH} is invalid: ${errors.map((error) => `${error.path || "/"} ${error.message}`).join("; ")}`);
+	return parsed;
+};
+const serializeLockFile = (lock) => canonicalJson(lock);
+//#endregion
+//#region src/sync/threeWay.ts
+const unchangedSinceBase = (remote, base) => remote.version === base.version || remote.hash === base.hash;
+const decideForLocal = (local, base, remote) => {
+	if (base && local.hash === base.hash) return {
+		action: "skip",
+		reason: "unchangedLocally"
+	};
+	if (!remote) return base ? {
+		action: "conflict",
+		reason: "deletedOnTarget"
+	} : { action: "create" };
+	if (remote.hash === local.hash) return {
+		action: "skip",
+		reason: "alreadyApplied"
+	};
+	if (!base) return {
+		action: "conflict",
+		reason: "existsOnTarget"
+	};
+	return unchangedSinceBase(remote, base) ? {
+		action: "update",
+		expectedVersion: remote.version
+	} : {
+		action: "conflict",
+		reason: "changedOnBoth"
+	};
+};
+const decideSync = ({ local, base, remote, prune }) => {
+	if (local) return decideForLocal(local, base, remote);
+	if (!base) return {
+		action: "skip",
+		reason: "remoteOnly"
+	};
+	if (!remote) return {
+		action: "skip",
+		reason: "alreadyDeleted"
+	};
+	if (!prune) return {
+		action: "skip",
+		reason: "deletedLocallyWithoutPrune"
+	};
+	return unchangedSinceBase(remote, base) ? {
+		action: "delete",
+		expectedVersion: remote.version
+	} : {
+		action: "conflict",
+		reason: "changedOnTargetBeforeDelete"
+	};
+};
+//#endregion
+//#region src/richtext/render.ts
+const ESCAPES = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+const escapeHtml = (value) => value.replace(/[&<>"']/g, (char) => ESCAPES[char] ?? char);
+/** Attribute values come from validated documents: strings and numbers only. */
+const textOf = (value) => typeof value === "string" || typeof value === "number" ? String(value) : "";
+const attribute = (name, value) => value === null || value === void 0 ? "" : ` ${name}="${escapeHtml(textOf(value))}"`;
+const BLOCK_TAGS = {
+	paragraph: "p",
+	blockquote: "blockquote",
+	bulletList: "ul",
+	listItem: "li",
+	table: "table",
+	tableRow: "tr",
+	tableHeader: "th",
+	tableCell: "td"
+};
+const renderMarks = (text, marks) => (marks ?? []).reduceRight((inner, mark) => {
+	switch (mark.type) {
+		case "bold": return `<strong>${inner}</strong>`;
+		case "italic": return `<em>${inner}</em>`;
+		case "code": return `<code>${inner}</code>`;
+		case "link": {
+			const href = textOf(mark.attrs?.href).trim();
+			if (!SAFE_LINK_PATTERN.test(href)) return inner;
+			const blank = mark.attrs?.target === "_blank";
+			return `<a${attribute("href", href)}${blank ? " target=\"_blank\" rel=\"noopener noreferrer nofollow\"" : ""}>${inner}</a>`;
+		}
+		default: return inner;
+	}
+}, escapeHtml(text));
+const cellAttributes = (node) => {
+	const colspan = Number(node.attrs?.colspan ?? 1);
+	const rowspan = Number(node.attrs?.rowspan ?? 1);
+	return `${colspan > 1 ? attribute("colspan", colspan) : ""}${rowspan > 1 ? attribute("rowspan", rowspan) : ""}`;
+};
+const renderNode = (node, resolveMedia) => {
+	const children = () => (node.content ?? []).map((child) => renderNode(child, resolveMedia)).join("");
+	switch (node.type) {
+		case "doc": return children();
+		case "text": return renderMarks(node.text ?? "", node.marks);
+		case "hardBreak": return "<br>";
+		case "horizontalRule": return "<hr>";
+		case "heading": {
+			const level = Math.min(6, Math.max(1, Number(node.attrs?.level ?? 1)));
+			return `<h${level}>${children()}</h${level}>`;
+		}
+		case "orderedList": {
+			const start = Number(node.attrs?.start ?? 1);
+			return `<ol${start !== 1 ? attribute("start", start) : ""}${attribute("type", node.attrs?.type)}>${children()}</ol>`;
+		}
+		case "codeBlock": {
+			const language = node.attrs?.language;
+			const text = (node.content ?? []).map((child) => escapeHtml(child.text ?? "")).join("");
+			return `<pre><code${language ? attribute("class", `language-${textOf(language)}`) : ""}>${text}</code></pre>`;
+		}
+		case "image": {
+			const mediaId = textOf(node.attrs?.mediaId);
+			const src = resolveMedia?.(mediaId);
+			if (!src) return "";
+			return `<img${attribute("src", src)}${attribute("alt", node.attrs?.alt ?? "")}${attribute("title", node.attrs?.title)}>`;
+		}
+		case "table": return `<table><tbody>${children()}</tbody></table>`;
+		case "tableHeader":
+		case "tableCell": {
+			const tag = BLOCK_TAGS[node.type];
+			return `<${tag}${cellAttributes(node)}>${children()}</${tag}>`;
+		}
+		default: {
+			const tag = BLOCK_TAGS[node.type];
+			return tag ? `<${tag}>${children()}</${tag}>` : "";
+		}
+	}
+};
+/** Renders a validated document to sanitized HTML. */
+const renderRichTextHtml = (document, resolveMedia) => renderNode(document.doc, resolveMedia);
+/** The document's text, blocks separated by blank lines (rich text → plain text conversions, search). */
+const richTextToPlainText = (document) => {
+	const blocks = [];
+	const inline = (node) => node.type === "text" ? node.text ?? "" : node.type === "hardBreak" ? "\n" : (node.content ?? []).map(inline).join("");
+	const walk = (node) => {
+		if (node.type === "paragraph" || node.type === "heading" || node.type === "codeBlock") {
+			blocks.push(inline(node));
+			return;
+		}
+		(node.content ?? []).forEach(walk);
+	};
+	walk(document.doc);
+	return blocks.join("\n\n");
+};
+/** Plain text → a document of paragraphs (blank lines split paragraphs; single newlines are hard breaks). */
+const plainTextToRichText = (text) => {
+	const paragraphs = text.replace(/\r\n?/g, "\n").split(/\n{2,}/).filter((paragraph) => paragraph.length > 0).map((paragraph) => {
+		const content = paragraph.split("\n").flatMap((line, index) => [...index > 0 ? [{ type: "hardBreak" }] : [], ...line.length > 0 ? [{
+			type: "text",
+			text: line
+		}] : []]);
+		return content.length > 0 ? {
+			type: "paragraph",
+			content
+		} : { type: "paragraph" };
+	});
+	return {
+		format: RICHTEXT_FORMAT,
+		version: 1,
+		doc: {
+			type: "doc",
+			content: paragraphs.length > 0 ? paragraphs : [{ type: "paragraph" }]
+		}
+	};
+};
+//#endregion
+export { API_KEY_PATTERN, BIGINTEGER_PATTERN, CANVAS_ELIGIBLE, CHANGE_KINDS, COMPONENT_TYPE_SUFFIXES, CUSTOM_EDITOR_ID_PATTERN, ComponentDefinitionInputSchema, ComponentDisplayInputSchema, DATA_TYPES, DATETIME_PATTERN, DATE_PATTERN, DECIMAL_PATTERN, DEFAULT_EDITORS, DEFINITION_KINDS, DefinitionInputSchema, EDITOR_CATALOGUE, EditorChoiceInputSchema, EnumValueSchema, FieldInputSchema, INLINE_TITLE_TYPES, 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, SETTINGS_SCHEMAS, SLUG_PATTERN, SORT_DIRECTIONS, STABLE_ID_PATTERN, STORAGE_FAMILY, STRIP_DEFAULT_COUNT, SchemaValidationError, TEXT_TITLE_FIELD_TYPES, TIME_PATTERN, TITLE_FIELD_TYPES, UID_PATTERN, UNIQUE_CAPABLE_DATA_TYPES, assignIds, canonicalJson, checkApiKeySyntax, checkDefaultValue, classifyChange, classifyChanges, classifyLocaleChange, collectionQueryName, createStableId, decideSync, diffDefinitions, effectiveLayout, effectiveTitleField, embeddedComponentIds, escapeHtml, findDependentModels, findReferencingDefinitions, foldApiKey, generatedNames, hashDefinition, isApiKeySyntaxValid, isCanvasEligible, isComponentDefinition, isCoverEligible, isCustomEditorId, isDataType, isEmptyRichText, isModelDefinition, isStableId, issue, listCompatibleEditors, normalizeDefinition, parseDefinition, parseLockFile, plainTextToRichText, renderRichTextHtml, renormalizeDefinition, richTextMediaIds, richTextToPlainText, routeKeyOf, serializeDefinition, serializeLockFile, sha256, stripFieldsOf, suggestPlural, summarizeChanges, toTypeName, validateDefinition, validateRichText, validateSchema, withDerivedPlural };
+
+//# sourceMappingURL=index.js.map