@bettercms-ai/kit 0.1.0 → 1.0.0

package/adapters/schema.js

@@ -0,0 +1,2203 @@
+import { CONTROL_TYPES, HELP_MORE_MAX, ITEM_NAME_RE, UI_CONTROLS } from "./prod-types.js";
+import { dockIconOf, tablerIconOf } from "./icons.js";
+import { CATALOG, FEATURES } from "./lossy.js";
+import { isDataTableProp, tableConfigFromOptions, tableOptionsFromConfig } from "../controls/table/prod.js";
+import { buttonFromProd, buttonToProd, datetimeFromProd, datetimeToProd, imageFromProd, imageToProd, linkFromProd, linkToProd, listFromProd, listToProd, ratingFromProd, ratingToProd, referenceFromProd, referenceToProd, scaleFromProd, scaleToProd, videoFromProd, videoToProd, zoneListFromProd, zoneListToProd } from "./values.js";
+//#region src/kit/adapters/schema.ts
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
+	if (!isObj(a) || !isObj(b)) return false;
+	return [...new Set([...Object.keys(a), ...Object.keys(b)].filter((k) => a[k] !== void 0 || b[k] !== void 0))].every((k) => deepEqual(a[k], b[k]));
+}
+var singular = (t) => t.endsWith("ies") ? `${t.slice(0, -3)}y` : t.endsWith("s") && !t.endsWith("ss") ? t.slice(0, -1) : t;
+var kebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "schema";
+var camel = (s) => s.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var ZONE_NAMES = new Set(typeof Intl.supportedValuesOf === "function" ? [...Intl.supportedValuesOf("timeZone"), "UTC"] : ["UTC"]);
+/** An IANA zone name (isTimeZoneName): ICU's canonical list, or a current name Intl itself accepts (Asia/Kolkata). */
+var isZone = (z) => {
+	if (ZONE_NAMES.has(z)) return true;
+	if (!/^[A-Za-z]+(?:\/[A-Za-z0-9_+-]+)+$/.test(z)) return false;
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: z });
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** The item type of a single-type array, as both directions name it when prod has no name for it. */
+var conventionItem = (fieldName, fieldTitle, itemLabel) => ({
+	name: singular(fieldName),
+	title: itemLabel ?? singular(fieldTitle)
+});
+/** A condition's value as the sibling's type reads it (prod stores rule values as strings). */
+function coerceRuleValue(siblingType, s) {
+	if (siblingType === "boolean") return s === "true" ? true : s === "false" ? false : s;
+	if ((siblingType === "number" || siblingType === "rating") && s.trim() !== "" && Number.isFinite(Number(s))) return Number(s);
+	return s;
+}
+/** V2 primitive types → the same-valued prod field type (fields lane). */
+var FIELD_TYPE = {
+	string: "text",
+	text: "longtext",
+	richtext: "richtext",
+	number: "number",
+	rating: "rating",
+	boolean: "boolean",
+	slug: "slug",
+	email: "email",
+	date: "date",
+	datetime: "datetime",
+	color: "color",
+	select: "select",
+	multiselect: "multiselect",
+	tags: "tags",
+	image: "image",
+	file: "file",
+	icon: "icon",
+	link: "link",
+	button: "button",
+	reference: "reference",
+	json: "json",
+	geopoint: "location",
+	url: "text",
+	code: "code",
+	video: "video"
+};
+/** V2 primitive types → prop types. */
+var PROP_TYPE = {
+	string: "text",
+	text: "longtext",
+	video: "video",
+	richtext: "richtext",
+	number: "number",
+	rating: "rating",
+	boolean: "boolean",
+	slug: "slug",
+	email: "email",
+	date: "date",
+	datetime: "datetime",
+	color: "color",
+	select: "select",
+	multiselect: "multiselect",
+	tags: "tags",
+	image: "image",
+	file: "file",
+	icon: "icon",
+	link: "link",
+	button: "button",
+	json: "json",
+	geopoint: "location",
+	url: "url",
+	code: "code"
+};
+/** Field types whose `config` the backend parses strictly (unknown keys stripped or refused). */
+var STRICT_CONFIG = new Set([
+	"array",
+	"reference",
+	"multi-reference",
+	"multiReference",
+	"date",
+	"datetime",
+	"component-ref",
+	"modular",
+	"sections",
+	"tags",
+	"rating",
+	"code",
+	"video"
+]);
+/** V2 list item types → prod `config.itemType` (ARRAY_ITEM_TYPES); a V2 `text` item reads back as `string`. */
+var PRIM_ITEM = {
+	string: "text",
+	text: "text",
+	number: "number",
+	date: "date",
+	image: "image",
+	link: "link",
+	richtext: "richtext"
+};
+var ENTRY_TARGET = (t) => ![
+	"page",
+	"form",
+	"shopify",
+	"collection"
+].includes(t);
+/** The old rating: a number with ui.control "rating" and these bounds read back as no `numeric` (read side only). */
+var RATING_CONFIG = {
+	min: 0,
+	max: 5,
+	step: .5
+};
+/**
+* V2 block-picker category (KitCategory, and the core examples' own) → the nearest prod ComponentCategory. A category
+* with no row has no prod twin; the server defaults the component to "custom".
+*/
+var CATEGORY_TO_PROD = {
+	"Navigation & chrome": "navbar",
+	Heroes: "hero",
+	"Features & storytelling": "content",
+	"Social proof": "social-proof",
+	"Media & galleries": "content",
+	Commerce: "conversion",
+	"Pricing & plans": "conversion",
+	"Conversion & forms": "conversion",
+	"Listings & feeds": "content",
+	"Long-form & docs": "content",
+	"Company & people": "content",
+	"Events & places": "content",
+	"Data & interactive": "section",
+	Navigation: "navbar",
+	Hero: "hero",
+	Content: "content",
+	Layout: "section"
+};
+/** The field types a kind:'block' model may hold (backend block-model-mapping.ts FIELD_PRIMITIVE). */
+var BLOCK_FIELD_TYPES = new Set([
+	"text",
+	"longtext",
+	"richtext",
+	"image",
+	"link",
+	"slug",
+	"email",
+	"phone",
+	"color",
+	"select",
+	"number",
+	"rating",
+	"date",
+	"datetime",
+	"boolean"
+]);
+/** A prop's config.minItems / maxItems cap (SLOT_ITEMS_CAP, componentPropDefSchema). */
+var SLOT_ITEMS_CAP = 50;
+/** Backend dock-vocabulary.ts SLIDER_MAX_STOPS: a slider's (max − min) / step. */
+var SLIDER_MAX_STOPS = 1e3;
+/**
+* The field types prod's unique flag accepts (uniqueFlagRules): a comparable scalar (UNIQUE_FIELD_TYPES, no two entries
+* share it; a reference only to one model) or a list (UNIQUE_ITEMS_FIELD_TYPES, no item repeats).
+*/
+var UNIQUE_TYPES = new Set([
+	"text",
+	"longtext",
+	"slug",
+	"email",
+	"phone",
+	"link",
+	"number",
+	"select",
+	"reference",
+	"date",
+	"array",
+	"multiselect",
+	"tags",
+	"multi-reference"
+]);
+/** Prop types whose value is a list (UNIQUE_LIST_PROP_TYPES), and the sub-field types a table row compares (UNIQUE_ROW_PROP_TYPES). */
+var UNIQUE_LIST_PROPS = new Set([
+	"multiselect",
+	"tags",
+	"multi-reference",
+	"table",
+	"array"
+]);
+var UNIQUE_ROW_PROPS = new Set([
+	"text",
+	"url",
+	"slug",
+	"email",
+	"phone",
+	"number",
+	"select",
+	"date"
+]);
+/** Types measured by minLength / maxLength (fields: LENGTH_FIELD_TYPES; props: LENGTH_TWIN), and those that take a pattern. */
+var LENGTH_FIELDS = new Set([
+	"text",
+	"longtext",
+	"richtext",
+	"document"
+]);
+var LENGTH_PROPS = new Set([
+	"text",
+	"url",
+	"longtext",
+	"richtext"
+]);
+var PATTERN_TYPES = new Set([
+	"text",
+	"longtext",
+	"url"
+]);
+/**
+* Leaf types whose value is an object a dotted preview path may read into (previewPathProblem OBJECT_VALUE_TYPES), and the
+* keys an image or video value holds (LEAF_VALUE_KEYS). V2 reads `image.alt`; prod stores the key as `altText`.
+*/
+var OBJECT_VALUE_TYPES = new Set([
+	"image",
+	"link",
+	"button",
+	"file",
+	"video",
+	"location",
+	"json",
+	"code",
+	"reference",
+	"multi-reference"
+]);
+var LEAF_VALUE_KEYS = {
+	image: [
+		"id",
+		"url",
+		"name",
+		"altText",
+		"width",
+		"height",
+		"focal",
+		"crop"
+	],
+	video: [
+		"url",
+		"poster",
+		"autoplay",
+		"loop",
+		"transcript"
+	]
+};
+var IMAGE_PATH_KEY = { alt: "altText" };
+var lose = (ctx, path, feature) => ctx.lossy.push({
+	path,
+	feature,
+	reason: FEATURES[feature].reason
+});
+var cat = (ctx, path, feature) => ctx.catalog.push({
+	path,
+	feature,
+	reason: CATALOG[feature]
+});
+/** Keys every type keeps, including a field degraded to json. */
+var COMMON_KEYS = new Set([
+	"name",
+	"title",
+	"type",
+	"description",
+	"helpMore",
+	"initialValue",
+	"validation",
+	"fieldset",
+	"group",
+	"hidden",
+	"readOnly",
+	"access",
+	"lockReason",
+	"advanced",
+	"localized",
+	"ai",
+	"placeholder"
+]);
+function shapeOf(f, lv, ctx, top) {
+	const props = ctx.lane === "props";
+	const deep = lv >= 10;
+	const of = Array.isArray(f.of) ? f.of : void 0;
+	/** a prop reference needs a content model to point at (refTargetNamed): with none it is stored as json */
+	const noEntry = (r) => props && !(r?.to ?? []).some(ENTRY_TARGET);
+	switch (f.type) {
+		case "object": return deep ? {
+			kind: "json",
+			type: "json",
+			feature: "depth>10"
+		} : {
+			kind: "object",
+			type: "object"
+		};
+		case "array": {
+			if (of && of.length > 1 && !props && of.every((i) => i.type === "object")) return {
+				kind: "modular",
+				type: "modular",
+				items: of
+			};
+			if (!of || of.length !== 1) return {
+				kind: "json",
+				type: "json",
+				feature: of ? "type:polymorphic-array" : "type:slot"
+			};
+			const item = of[0];
+			if (item.type === "object") return deep ? {
+				kind: "json",
+				type: "json",
+				feature: "depth>10"
+			} : {
+				kind: "zones",
+				type: props ? "table" : "array",
+				item
+			};
+			if (item.type === "reference") return noEntry(item.reference) ? {
+				kind: "json",
+				type: "json",
+				feature: "reference target"
+			} : {
+				kind: "refs",
+				type: "multi-reference",
+				item
+			};
+			const prim = PRIM_ITEM[item.type];
+			if (prim) return {
+				kind: "itemType",
+				type: "array",
+				item,
+				itemType: prim
+			};
+			return {
+				kind: "json",
+				type: "json",
+				feature: "type:primitive-array"
+			};
+		}
+		case "slot": return {
+			kind: "json",
+			type: "json",
+			feature: "type:slot"
+		};
+		case "table": return props ? {
+			kind: "leaf",
+			type: "table"
+		} : {
+			kind: "json",
+			type: "json",
+			feature: "type:table"
+		};
+		case "reference":
+			if (props && top && f.reference?.to?.length === 1 && f.reference.to[0] === "form" && !f.reference.filter) return {
+				kind: "leaf",
+				type: "form"
+			};
+			return noEntry(f.reference) ? {
+				kind: "json",
+				type: "json",
+				feature: "reference target"
+			} : {
+				kind: "leaf",
+				type: "reference"
+			};
+		default: {
+			const t = props ? PROP_TYPE[f.type] : FIELD_TYPE[f.type];
+			return t ? {
+				kind: "leaf",
+				type: t
+			} : {
+				kind: "json",
+				type: "json",
+				feature: "unsupported key"
+			};
+		}
+	}
+}
+var trunc = (ctx, at, s, max, feature) => {
+	if (s.length <= max) return s;
+	lose(ctx, at, feature);
+	return s.slice(0, max);
+};
+function convertField(f, at, lv, ctx, siblings, top, inTable = false) {
+	const props = ctx.lane === "props";
+	const shape = shapeOf(f, lv, ctx, top);
+	const node = {
+		key: f.name,
+		label: f.title,
+		type: shape.type,
+		config: {},
+		ui: {}
+	};
+	const twins = siblings.slice(0, Math.max(0, siblings.indexOf(f))).filter((s) => s.name === f.name).length;
+	if (twins) {
+		node.key = `${f.name}_${twins + 1}`;
+		lose(ctx, `${at}/name`, "duplicate name");
+	}
+	const nesting = shape.kind === "object" || shape.kind === "zones";
+	/** a list of items (objects, block models, scalars or entries): ui.itemLabel names one item */
+	const listy = shape.kind === "zones" || shape.kind === "modular" || shape.kind === "itemType" || shape.kind === "refs";
+	const looseConfig = props || !STRICT_CONFIG.has(shape.type);
+	if (shape.kind === "json") lose(ctx, `${at}/type`, shape.feature);
+	if (!props && f.type === "url") node.config.inputType = "url";
+	if (shape.type === "datetime" && !props) node.config.includeTime = true;
+	if (shape.kind === "leaf" && shape.type === "table") node.config.mode = "data";
+	if (listy) {
+		const label = f.itemNoun !== void 0 ? capitalize(f.itemNoun) : shape.kind === "zones" && shape.item.title !== conventionItem(f.name, f.title).title ? shape.item.title : void 0;
+		if (label !== void 0 && label.length <= 24) node.ui.itemLabel = label;
+	}
+	const devLock = f.access?.edit === "schema.manage" && !!f.lockReason;
+	for (const k of Object.keys(f)) {
+		if (f[k] === void 0) continue;
+		const p = `${at}/${k}`;
+		if (shape.kind === "json" && !COMMON_KEYS.has(k)) {
+			lose(ctx, p, shape.feature);
+			continue;
+		}
+		switch (k) {
+			case "name":
+			case "title":
+			case "type": break;
+			case "description":
+				node.helpText = trunc(ctx, p, f.description, props ? 200 : 500, "help>limit");
+				break;
+			case "helpMore":
+				node.helpMore = trunc(ctx, p, f.helpMore, HELP_MORE_MAX, "help>limit");
+				break;
+			case "placeholder":
+				if (props) node.placeholder = trunc(ctx, p, f.placeholder, 120, "help>limit");
+				else if (looseConfig) node.placeholder = f.placeholder;
+				else node.ui.placeholder = trunc(ctx, p, f.placeholder, 120, "help>limit");
+				break;
+			case "initialValue":
+				if (props && (shape.type === "reference" || shape.type === "multi-reference")) cat(ctx, p, "seeded instance");
+				else node.defaultValue = defaultToProd(f, shape, f.initialValue, p, ctx, lv, top);
+				break;
+			case "validation":
+				validationToProd(f, shape, node, p, ctx, inTable, top);
+				break;
+			case "options":
+				optionsToProd(f, shape, node, p, ctx);
+				break;
+			case "layout":
+				layoutToProd(f, shape, node, p, ctx);
+				break;
+			case "fields":
+				if (shape.kind === "object") node.children = f.fields.map((c, i) => convertField(c, `${p}/${i}`, lv + 1, ctx, f.fields, false));
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "of":
+				ofToProd(f, shape, node, p, lv, ctx);
+				break;
+			case "openMode":
+				if (nesting) node.openMode = f.openMode;
+				else lose(ctx, p, "openMode");
+				break;
+			case "preview":
+				if (shape.kind === "object") node.ui.preview = previewToProd(f.preview, f.fields ?? [], p, ctx);
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "fieldset":
+			case "group": break;
+			case "hidden":
+				if (typeof f.hidden === "boolean") node.ui.hidden = f.hidden;
+				else {
+					const showIf = conditionToShowIf(f.hidden, p, siblings, ctx, props && top);
+					if (showIf) node.showIf = showIf;
+				}
+				break;
+			case "readOnly":
+				if (f.readOnly === true && !devLock) node.readOnly = true;
+				else lose(ctx, p, "access");
+				break;
+			case "access": {
+				const access = {};
+				for (const [ak, av] of Object.entries(f.access)) {
+					if (av === void 0) continue;
+					if (ak === "view" && av === "schema.view") access.view = av;
+					else if (ak === "edit" && av === "schema.manage") access.edit = av;
+					else lose(ctx, `${p}/${ak}`, "access");
+				}
+				if (Object.keys(access).length) node.ui.access = access;
+				if (devLock) node.readOnly = "developer";
+				break;
+			}
+			case "lockReason":
+				node.lockReason = trunc(ctx, p, f.lockReason, 200, "help>limit");
+				break;
+			case "localized":
+				node.localized = f.localized;
+				break;
+			case "advanced":
+				node.advanced = f.advanced;
+				break;
+			case "ai":
+				cat(ctx, p, "ai");
+				break;
+			case "reference":
+				if (shape.kind === "leaf" && shape.type === "reference") referenceToConfig(f.reference, node, p, ctx);
+				else if (shape.type !== "form") lose(ctx, p, "unsupported key");
+				break;
+			case "numeric":
+				numericToProd(f, node, p, ctx);
+				break;
+			case "scale":
+				if (shape.type === "number") scaleToConfig(f.scale, node, p, ctx);
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "icon": {
+				const dock = shape.kind === "object" || shape.kind === "modular" ? dockIconOf(f.icon) : void 0;
+				if (dock) node.ui.icon = dock;
+				else lose(ctx, p, "icon");
+				break;
+			}
+			case "rows":
+				if ((shape.type === "text" || shape.type === "longtext") && isWhole(f.rows, 1, 40)) node.ui.rows = f.rows;
+				else lose(ctx, p, "rows");
+				break;
+			case "synced": {
+				const from = f.synced.from;
+				if (typeof from === "string" && from === from.trim() && from.length >= 1 && from.length <= 64 && Object.keys(f.synced).every((x) => x === "from")) node.ui.synced = { from };
+				else lose(ctx, p, "synced");
+				break;
+			}
+			case "slotSettings":
+				lose(ctx, p, "slotSettings");
+				break;
+			case "itemNoun":
+				if (!listy || node.ui.itemLabel?.toLowerCase() !== f.itemNoun) lose(ctx, p, "itemNoun");
+				break;
+			case "arrayLayout":
+				if (shape.kind === "zones" || shape.kind === "modular") node.ui.layout = f.arrayLayout;
+				else if ((shape.kind === "itemType" || shape.kind === "refs") && f.arrayLayout === "grid") node.ui.layout = "gallery";
+				else lose(ctx, p, "layout");
+				break;
+			case "valueShape":
+				if (shape.type === "link" || shape.type === "image" || shape.type === "button") node.ui.valueShape = f.valueShape;
+				else lose(ctx, p, "valueShape");
+				break;
+			case "timezone":
+				if (shape.type === "date" || shape.type === "datetime") {
+					const tz = f.timezone;
+					const zone = typeof tz === "boolean" || tz === "site" ? tz : typeof tz === "string" && tz.startsWith("fixed:") && isZone(tz.slice(6)) ? tz.slice(6) : void 0;
+					if (zone !== void 0) node.config.timezone = zone;
+					else lose(ctx, p, "timezone");
+				} else lose(ctx, p, "unsupported key");
+				break;
+			case "language":
+				if (shape.type === "code" && typeof f.language === "string") node.config.language = f.language;
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "languages":
+				if (shape.type === "code" && Array.isArray(f.languages) && f.languages.every((l) => typeof l === "string")) node.config.languages = [...f.languages];
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "table":
+				if (shape.kind === "leaf" && shape.type === "table") Object.assign(node.config, tableConfigFromOptions(f.table));
+				else lose(ctx, p, "type:table");
+				break;
+			default: lose(ctx, p, "unsupported key");
+		}
+	}
+	if (f.itemNoun === void 0 && shape.kind === "zones" && node.ui.itemLabel !== void 0) cat(ctx, `${at}/itemNoun`, "itemNoun (derived)");
+	placeInSet(f, node, at, ctx, top, siblings);
+	if (node.ui.control === "slider" && !sliderOk(node.config)) {
+		delete node.ui.control;
+		lose(ctx, `${at}/layout`, "layout");
+	}
+	return node;
+}
+var isWhole = (n, lo = 0, hi = Infinity) => typeof n === "number" && Number.isInteger(n) && n >= lo && n <= hi;
+var compiles = (re) => {
+	try {
+		new RegExp(re);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var ratingIsDefault = (c) => c.min === RATING_CONFIG.min && c.max === RATING_CONFIG.max && c.step === RATING_CONFIG.step;
+/** Backend controlHardening: a slider spans min < max; a set step is > 0 with at most SLIDER_MAX_STOPS stops. */
+function sliderOk({ min, max, step }) {
+	if (!(typeof min === "number" && typeof max === "number" && min < max)) return false;
+	return step === void 0 || typeof step === "number" && step > 0 && (max - min) / step <= SLIDER_MAX_STOPS;
+}
+/** Where a field sits: its tab (fields lane) or prop group (props lane). */
+function placeInSet(f, node, at, ctx, top, siblings) {
+	if (ctx.lane === "props") {
+		if (f.group !== void 0) lose(ctx, `${at}/group`, "group (props)");
+		if (f.fieldset === void 0) return;
+		const set = ctx.propSets.get(f.fieldset);
+		if (!set) return lose(ctx, `${at}/fieldset`, "fieldset collision");
+		let defined = ctx.definedGroups.get(siblings);
+		if (!defined) ctx.definedGroups.set(siblings, defined = /* @__PURE__ */ new Set());
+		if (defined.has(set.name)) node.ui.group = { id: set.name };
+		else {
+			defined.add(set.name);
+			node.ui.group = propGroupOf(set, ctx);
+		}
+		return;
+	}
+	const set = f.fieldset !== void 0 && ctx.sets.has(f.fieldset) ? f.fieldset : void 0;
+	if (f.fieldset !== void 0 && !set) lose(ctx, `${at}/fieldset`, "fieldset collision");
+	if (!top) {
+		if (f.group !== void 0) lose(ctx, `${at}/group`, "group (nested)");
+		if (set) node.fieldsetId = set;
+		return;
+	}
+	const tab = set ? ctx.sets.get(set) : void 0;
+	if (f.group !== void 0 && !ctx.tabs.has(f.group)) lose(ctx, `${at}/group`, ctx.droppedTabs.get(f.group) ?? "unsupported key");
+	else if (set && tab !== f.group) lose(ctx, `${at}/group`, "fieldset spans groups");
+	node.fieldsetId = set ?? (f.group !== void 0 && ctx.tabs.has(f.group) ? f.group : void 0);
+}
+/** A V2 fieldset as the inline prop group its first member defines (what propSetsFor found unstorable is named there). */
+function propGroupOf(s, ctx) {
+	const g = {
+		id: s.name,
+		label: s.title.slice(0, 32),
+		kind: "group"
+	};
+	if (s.collapsed !== void 0) g.collapsed = s.collapsed;
+	if (groupDescriptionOk(s.description)) g.description = s.description;
+	if (s.columns !== void 0) g.columns = s.columns;
+	if (s.collapsible !== void 0) g.collapsible = s.collapsible;
+	if (s.layout !== void 0) g.layout = s.layout;
+	if (ctx.groupOrder) g.order = Math.min(99, ctx.propOrder.get(s.name) ?? 0);
+	return g;
+}
+var groupDescriptionOk = (d) => typeof d === "string" && d === d.trim() && d.length >= 1 && d.length <= 200;
+/** The zone a datetime field fixes, if any (what lets a stored instant read back with its [Zone]). */
+var fixedZone = (f) => typeof f.timezone === "string" && f.timezone.startsWith("fixed:") ? f.timezone.slice(6) : void 0;
+/**
+* A field default: forward through the value adapters, then read back the way toTypeSchema will; every leaf that does
+* not come back is named (so the lossy list matches what the read side really returns). Objects and list rows go
+* through their child fields' adapters too.
+*/
+function defaultToProd(f, shape, v, at, ctx, lv, top) {
+	const plan = writePlan(f, shape, lv, ctx, top);
+	const out = planToProd(plan, v);
+	for (const d of diffPaths(v, planFromProd(plan, out))) lose(ctx, `${at}${d}`, "default value");
+	return out;
+}
+var AS_IS = { k: "as-is" };
+/** The write side's plan, from the V2 field and the shape it is stored as. */
+function writePlan(f, shape, lv, ctx, top) {
+	const kids = (fields) => new Map(fields.map((c) => [c.name, writePlan(c, shapeOf(c, lv + 1, ctx, false), lv + 1, ctx, false)]));
+	switch (shape.kind) {
+		case "json": return AS_IS;
+		case "itemType": return shape.itemType === "image" || shape.itemType === "link" ? {
+			k: "list",
+			item: shape.itemType
+		} : AS_IS;
+		case "object": return {
+			k: "object",
+			fields: kids(f.fields ?? [])
+		};
+		case "zones": return {
+			k: "rows",
+			zoned: ctx.lane === "fields",
+			fields: kids(shape.item.fields ?? [])
+		};
+		case "modular": {
+			const top1 = (fields) => new Map(fields.map((c) => [c.name, writePlan(c, shapeOf(c, 1, ctx, false), 1, ctx, false)]));
+			return {
+				k: "modular",
+				types: new Map(shape.items.map((i) => [i.name, top1(i.fields ?? [])]))
+			};
+		}
+		case "refs": return { k: "refs" };
+		case "leaf":
+			if (f.type === "link" || f.type === "url") return { k: "link" };
+			if (f.type === "button" || f.type === "image") return { k: f.type };
+			if (f.type === "datetime") return {
+				k: "datetime",
+				zone: fixedZone(f)
+			};
+			if (f.type === "reference") return { k: top && shape.type === "form" ? "form" : "ref" };
+			return leafPlan(f, shape.type);
+	}
+}
+/** The plan of a leaf whose value needs its own adapter but no link / reference handling (both directions agree). */
+function leafPlan(f, prodType) {
+	if (f.type === "video") return { k: "video" };
+	if (f.type === "rating") return {
+		k: "rating",
+		scale: {
+			min: f.numeric?.min,
+			max: f.numeric?.max,
+			step: f.numeric?.step
+		}
+	};
+	if (f.type === "number" && f.scale) return {
+		k: "scale",
+		scale: f.scale
+	};
+	return prodType === "number" ? { k: "number" } : AS_IS;
+}
+/**
+* The read side's plan, from the V2 field read back (`zoned`: lists read from an array's repeatable zone; `modular`:
+* lists read from a modular field, whose item fields live in their block models and pass as stored).
+*/
+function readPlan(f, prodType, zoned, modular) {
+	const kids = (fields) => new Map(fields.map((c) => [c.name, readPlan(c, "", zoned, modular)]));
+	switch (f.type) {
+		case "link":
+		case "url": return { k: "link" };
+		case "button":
+		case "image": return { k: f.type };
+		case "datetime": return {
+			k: "datetime",
+			zone: fixedZone(f)
+		};
+		case "date": return { k: "date" };
+		case "reference": return { k: prodType === "form" ? "form" : "ref" };
+		case "object": return {
+			k: "object",
+			fields: kids(f.fields ?? [])
+		};
+		case "array": {
+			if (modular.has(f)) return {
+				k: "modular",
+				types: new Map((Array.isArray(f.of) ? f.of : []).map((i) => [i.name, kids(i.fields ?? [])]))
+			};
+			const item = Array.isArray(f.of) && f.of.length === 1 ? f.of[0] : void 0;
+			if (item?.type === "object") return {
+				k: "rows",
+				zoned: zoned.has(f),
+				fields: kids(item.fields ?? [])
+			};
+			if (item?.type === "image" || item?.type === "link") return {
+				k: "list",
+				item: item.type
+			};
+			return item?.type === "reference" ? { k: "refs" } : AS_IS;
+		}
+		default: return leafPlan(f, prodType);
+	}
+}
+/**
+* The plan for ONE leaf field read from prod type `prodType` (a link, an image, a reference…), for a host that edits a
+* single field's value outside a whole read (the dock's legacy controls). Objects and lists need the read's own plan
+* (`ToTypeSchemaOptions.plans`), which knows which lists are zoned or modular.
+*/
+function leafValuePlan(f, prodType) {
+	return readPlan(f, prodType, /* @__PURE__ */ new WeakSet(), /* @__PURE__ */ new WeakSet());
+}
+/**
+* A V2 value → what prod stores. `lost` (optional) collects every V2 key prod cannot keep, as a path under the value
+* ("cta/style", "(value)" for the value itself): a caller that finds any must refuse the write and name them.
+*/
+function planToProd(plan, v, lost, at = "") {
+	if (v === void 0) return void 0;
+	const take = (r) => {
+		if (lost) for (const l of r.lost) lost.push(at ? `${at}/${l}` : l);
+		return r.value;
+	};
+	const under = (k) => at ? `${at}/${k}` : String(k);
+	switch (plan.k) {
+		case "link": return take(linkToProd(v));
+		case "button": return take(buttonToProd(v));
+		case "image": return take(imageToProd(v));
+		case "datetime": return take(datetimeToProd(v, { zone: plan.zone }));
+		case "form": return take(referenceToProd(v, { to: "form" }));
+		case "ref":
+		case "refs": return take(referenceToProd(v));
+		case "number":
+			if (typeof v === "number" || v === null) return v;
+			lost?.push(at || "(value)");
+			return;
+		case "video": return take(videoToProd(v));
+		case "list": return take(listToProd(v, plan.item));
+		case "scale": return take(scaleToProd(v, plan.scale));
+		case "rating": return take(ratingToProd(v, plan.scale));
+		case "object": return mapKeys(v, plan.fields, (p, x, k) => planToProd(p, x, lost, under(k)));
+		case "rows": {
+			if (!Array.isArray(v)) return v;
+			const rows = v.map((row, i) => mapKeys(row, plan.fields, (p, x, k) => planToProd(p, x, lost, `${under(i)}/${k}`)));
+			return plan.zoned ? zoneListToProd(rows) : rows;
+		}
+		case "modular":
+			if (!Array.isArray(v)) return v;
+			return v.map((row, i) => {
+				if (!isObj(row) || typeof row._type !== "string") return row;
+				const { _key, _type, ...rest } = row;
+				const fields = plan.types.get(_type);
+				return {
+					__id: typeof _key === "string" && _key ? _key : `${kebab(_type)}-${i + 1}`,
+					__type: kebab(_type),
+					data: fields ? mapKeys(rest, fields, (p, x, k) => planToProd(p, x, lost, `${under(i)}/${k}`)) : rest
+				};
+			});
+		default: return v;
+	}
+}
+/** The keys the kit reads back from a stored image object (imageFromProd) and writes again (imageToProd). */
+var IMAGE_KIT_KEYS = new Set([
+	"url",
+	"id",
+	"name",
+	"altText",
+	"focal"
+]);
+/** Every key of a stored image the kit cannot hand back: a crop (read back only with the asset's pixel size) or a key it does not model. */
+function imageStoredLoss(v, rel, loss) {
+	if (!isObj(v)) return;
+	for (const [k, x] of Object.entries(v)) {
+		if (IMAGE_KIT_KEYS.has(k) || x === void 0) continue;
+		if (k === "crop") {
+			if (x != null) loss(`${rel}/crop`, "A saved crop is not read back by the kit; editing the image would drop it.");
+		} else loss(`${rel}/${k}`, `The image's saved "${k}" is not kept by the kit; editing the image would drop it.`);
+	}
+}
+var datedLossReason = (v) => isObj(v) && ("date" in v || "time" in v || "timezone" in v) ? "A stored date-time in the older {date,time,timezone} form; the kit can't read it, so editing it would replace it." : "A stored date/time that is not an ISO string can't be read by the kit; editing it would replace it.";
+/** A stored prod value → the V2 value. `loss(rel, reason)`: what the prod value carries that the V2 value cannot (rel is
+*  under the value, "/0/modelSlug"); a caller that hears any must not write the value back through V2. */
+function planFromProd(plan, v, loss, rel = "") {
+	if (v === void 0) return void 0;
+	switch (plan.k) {
+		case "link": return linkFromProd(v);
+		case "button": return buttonFromProd(v);
+		case "image":
+			if (loss) imageStoredLoss(v, rel, loss);
+			return imageFromProd(v);
+		case "datetime":
+		case "date":
+			if (loss && v !== null && typeof v !== "string") loss(rel || "(value)", datedLossReason(v));
+			return plan.k === "date" ? v : datetimeFromProd(v, { zone: plan.zone });
+		case "video": return videoFromProd(v);
+		case "list":
+			if (loss && plan.item === "image" && Array.isArray(v)) v.forEach((x, i) => imageStoredLoss(x, `${rel}/${i}`, loss));
+			return listFromProd(v, plan.item);
+		case "scale": return scaleFromProd(v);
+		case "rating": return ratingFromProd(v, plan.scale);
+		case "form": return referenceFromProd(v);
+		case "ref":
+		case "refs":
+			if (loss) {
+				for (const [i, x] of (Array.isArray(v) ? v : [v]).entries()) if (isObj(x) && x.modelSlug !== void 0) loss(`${rel}${Array.isArray(v) ? `/${i}` : ""}/modelSlug`, "A V2 reference stores the target id; the polymorphic modelSlug is dropped.");
+				else if (isObj(x) && referenceFromProd(x) === null) loss(`${rel}${Array.isArray(v) ? `/${i}` : ""}` || "(value)", "A stored reference the kit can't read; editing it would drop it.");
+			}
+			return referenceFromProd(v);
+		case "object": return mapKeys(v, plan.fields, (p, x, k) => planFromProd(p, x, loss, `${rel}/${k}`));
+		case "rows": {
+			const rows = plan.zoned ? zoneListFromProd(v) : v;
+			return Array.isArray(rows) ? rows.map((row, i) => mapKeys(row, plan.fields, (p, x, k) => planFromProd(p, x, loss, `${rel}/${i}/${k}`))) : rows;
+		}
+		case "modular": return Array.isArray(v) ? v.map((row, i) => {
+			if (!isObj(row) || typeof row.__type !== "string") return row;
+			const data = isObj(row.data) ? row.data : {};
+			const fields = plan.types.get(camel(row.__type));
+			const back = fields ? mapKeys(data, fields, (p, x, k) => planFromProd(p, x, loss, `${rel}/${i}/${k}`)) : data;
+			return {
+				_key: row.__id,
+				_type: camel(row.__type),
+				...back
+			};
+		}) : v;
+		default: return v;
+	}
+}
+/** Each key of an object value through its child field's plan; keys with no field ride along as they are. */
+function mapKeys(v, fields, fn) {
+	if (!isObj(v)) return v;
+	const out = {};
+	for (const [k, x] of Object.entries(v)) {
+		const plan = fields.get(k);
+		const y = plan ? fn(plan, x, k) : x;
+		if (y !== void 0) out[k] = y;
+	}
+	return out;
+}
+/** Every leaf (a JSON pointer under the value, "" for the value itself) where `a` and `b` differ; undefined = absent. */
+function diffPaths(a, b, path = "", out = []) {
+	if (deepEqual(a, b)) return out;
+	if ((isObj(a) || a === void 0) && (isObj(b) || b === void 0) && (a !== void 0 || b !== void 0)) {
+		const A = a ?? {};
+		const B = b ?? {};
+		for (const k of new Set([...Object.keys(A), ...Object.keys(B)])) diffPaths(A[k], B[k], `${path}/${k}`, out);
+	} else if (Array.isArray(a) && Array.isArray(b)) for (let i = 0; i < Math.max(a.length, b.length); i++) diffPaths(a[i], b[i], `${path}/${i}`, out);
+	else out.push(path);
+	return out;
+}
+function validationToProd(f, shape, node, at, ctx, inTable, top) {
+	const props = ctx.lane === "props";
+	const val = f.validation;
+	const t = shape.type;
+	const leaf = shape.kind === "leaf";
+	const lengthy = leaf && (props ? LENGTH_PROPS : LENGTH_FIELDS).has(t);
+	const patternOk = leaf && (props ? PATTERN_TYPES : LENGTH_FIELDS).has(t) && t !== "richtext" && t !== "document" && typeof val.pattern === "string" && val.pattern.length <= 200 && compiles(val.pattern);
+	/** the pair each key bounds, so a min over its max is named rather than refused at save */
+	const pairs = [];
+	const set = (key, n, feature, lo, hi) => {
+		node.config[key] = n;
+		if (!pairs.some((x) => x[0] === lo)) pairs.push([
+			lo,
+			hi,
+			`${at}/min`,
+			`${at}/max`,
+			feature
+		]);
+	};
+	for (const k of Object.keys(val)) {
+		const v = val[k];
+		if (v === void 0) continue;
+		const p = `${at}/${k}`;
+		if (shape.kind === "json" && k !== "required" && k !== "recommendedMax") {
+			lose(ctx, p, shape.feature);
+			continue;
+		}
+		switch (k) {
+			case "required":
+				node.required = val.required;
+				break;
+			case "min":
+			case "max": {
+				const n = v;
+				const lo = k === "min";
+				if (lengthy) if (isWhole(n)) set(lo ? "minLength" : "maxLength", n, "validation.length", "minLength", "maxLength");
+				else lose(ctx, p, "validation.length");
+				else if (t === "number") {
+					const b = node.config.validation ??= {};
+					b[k] = n;
+				} else if (t === "rating") lose(ctx, p, "rating bounds");
+				else if (shape.kind === "zones" || shape.kind === "modular" || shape.kind === "itemType") if (props && top ? isWhole(n, lo ? 0 : 1, SLOT_ITEMS_CAP) : isWhole(n)) set(lo ? "minItems" : "maxItems", n, "validation.items", "minItems", "maxItems");
+				else lose(ctx, p, "validation.items");
+				else if (shape.kind === "refs" || t === "multiselect" || t === "tags") if (t === "tags" ? isWhole(n, lo ? 0 : 1, 500) : isWhole(n)) set(k, n, "validation.items", "min", "max");
+				else lose(ctx, p, "validation.items");
+				else lose(ctx, p, "validation.length");
+				break;
+			}
+			case "recommendedMax":
+				if (isWhole(v, 1)) node.recommendedMax = v;
+				else lose(ctx, p, "validation.recommendedMax");
+				break;
+			case "pattern":
+				if (patternOk) node.config.pattern = v;
+				else lose(ctx, p, "validation.pattern");
+				break;
+			case "patternMessage":
+				if (patternOk && typeof v === "string" && v.trim() !== "" && v.length <= 200) node.config.patternMessage = v;
+				else lose(ctx, p, "validation.patternMessage");
+				break;
+			case "unique":
+				if (val.unique === false) node.unique = false;
+				else if (props) if (UNIQUE_LIST_PROPS.has(t) || inTable && UNIQUE_ROW_PROPS.has(t)) node.unique = true;
+				else cat(ctx, p, "not applicable (props)");
+				else {
+					const polymorphic = t === "reference" && (f.reference?.to ?? []).filter(ENTRY_TARGET).length > 1;
+					if (UNIQUE_TYPES.has(t) && !polymorphic) node.unique = true;
+					else lose(ctx, p, "validation.unique");
+				}
+				break;
+			default: lose(ctx, p, "unsupported key");
+		}
+	}
+	const b = node.config.validation;
+	if (b && b.min !== void 0 && b.max !== void 0 && b.min > b.max) {
+		delete node.config.validation;
+		lose(ctx, `${at}/min`, "validation.items");
+		lose(ctx, `${at}/max`, "validation.items");
+	}
+	for (const [lo, hi, pLo, pHi, feature] of pairs) {
+		const a = node.config[lo];
+		const z = node.config[hi];
+		if (typeof a === "number" && typeof z === "number" && a > z) {
+			delete node.config[lo];
+			delete node.config[hi];
+			lose(ctx, pLo, feature);
+			lose(ctx, pHi, feature);
+		}
+	}
+}
+function optionsToProd(f, shape, node, at, ctx) {
+	if (shape.type !== "select" && shape.type !== "multiselect" && shape.type !== "tags") return lose(ctx, at, "unsupported key");
+	const opts = f.options;
+	const icons = opts.map((o) => o.icon === void 0 ? void 0 : dockIconOf(o.icon));
+	const allIcons = opts.every((o, i) => o.icon === void 0 || icons[i] !== void 0);
+	node.options = opts.map((o, i) => {
+		const out = {
+			label: o.label,
+			value: o.value
+		};
+		if (o.icon !== void 0) if (allIcons) out.icon = icons[i];
+		else lose(ctx, `${at}/${i}/icon`, "option icon");
+		const d = o.description;
+		if (d !== void 0) if (typeof d === "string" && d.trim() !== "" && !/[\r\n]/.test(d) && d.length <= 140) out.description = d;
+		else lose(ctx, `${at}/${i}/description`, "option description");
+		for (const k of Object.keys(o)) if (![
+			"value",
+			"label",
+			"icon",
+			"description"
+		].includes(k)) lose(ctx, `${at}/${i}/${k}`, "unsupported key");
+		return out;
+	});
+}
+/** V2 layouts → prod ui.control (a leaf's control) or ui.layout (a list's rows); dock-vocabulary.ts controlHardening rules. */
+function layoutToProd(f, shape, node, at, ctx) {
+	const l = f.layout;
+	const t = shape.type;
+	const n = f.options?.length ?? 0;
+	if (l === "segmented" && t === "select") if (n >= 2 && n <= 4) node.ui.control = "segmented";
+	else if (n >= 5) {
+		node.ui.control = n <= 6 ? "radio" : "dropdown";
+		lose(ctx, at, "segmented>4");
+	} else lose(ctx, at, "layout");
+	else if (l === "slider" && t === "number" && f.type === "number") node.ui.control = "slider";
+	else if (UI_CONTROLS.includes(l) && l !== "segmented" && l !== "slider" && CONTROL_TYPES[l]?.includes(t)) node.ui.control = l;
+	else if (l === "list" && (shape.kind === "zones" || shape.kind === "itemType" || shape.kind === "modular" || shape.kind === "refs") && f.arrayLayout === void 0) node.ui.layout = "rows";
+	else lose(ctx, at, "layout");
+}
+/** The prod type a V2 field is stored as, for a preview path reading into it (no loss is reported). */
+function storedType(f, ctx) {
+	return shapeOf(f, 1, {
+		...ctx,
+		lossy: [],
+		catalog: []
+	}, false).type;
+}
+/** The V2 fields a preview path segment may name below `f` (an object's fields, a list's item fields), or null for a leaf. */
+function previewKids(f) {
+	if (f.type === "object") return f.fields ?? [];
+	if (f.type === "array" && Array.isArray(f.of) && f.of.length === 1 && f.of[0].type === "object") return f.of[0].fields ?? [];
+	return null;
+}
+/**
+* A V2 preview path → the path prod stores (previewPathProblem): the first segment a child, each later one a child of the
+* node before it, or a key of an object-valued leaf (`image.alt` is stored `image.altText`). undefined: no prod form.
+*/
+function previewPathToProd(path, children, ctx) {
+	const segs = path.split(".");
+	let node = children.find((c) => c.name === segs[0]);
+	if (!node) return void 0;
+	const out = [segs[0]];
+	for (let i = 1; i < segs.length; i++) {
+		const kids = previewKids(node);
+		if (kids) {
+			const next = kids.find((c) => c.name === segs[i]);
+			if (!next) return void 0;
+			out.push(segs[i]);
+			node = next;
+			continue;
+		}
+		const type = storedType(node, ctx);
+		if (!OBJECT_VALUE_TYPES.has(type)) return void 0;
+		const key = type === "image" ? IMAGE_PATH_KEY[segs[i]] ?? segs[i] : segs[i];
+		if (LEAF_VALUE_KEYS[type] && !LEAF_VALUE_KEYS[type].includes(key)) return void 0;
+		return [
+			...out,
+			key,
+			...segs.slice(i + 1)
+		].join(".");
+	}
+	return out.join(".");
+}
+function previewToProd(pv, children, at, ctx) {
+	const out = {};
+	for (const k of Object.keys(pv)) {
+		const v = pv[k];
+		if (v === void 0) continue;
+		if (k === "title" || k === "subtitle" || k === "media") {
+			const stored = previewPathToProd(v, children, ctx);
+			if (stored !== void 0) out[k] = stored;
+			else lose(ctx, `${at}/${k}`, "preview path");
+		} else if (k === "fallback") {
+			const t = v.trim();
+			if (t && t === v && t.length <= 60) out.fallback = v;
+			else lose(ctx, `${at}/${k}`, "help>limit");
+		} else if (k === "icon") {
+			const dock = dockIconOf(v);
+			if (dock) out.icon = dock;
+			else lose(ctx, `${at}/${k}`, "preview icon");
+		} else lose(ctx, `${at}/${k}`, "unsupported key");
+	}
+	return out;
+}
+/** A list item's name and title: the convention, else ui.itemName / ui.itemTitle (chromeUiProblems). */
+function itemIdentity(item, conv, node, ip, ctx) {
+	if (item.name !== conv.name) if (ITEM_NAME_RE.test(item.name)) node.ui.itemName = item.name;
+	else lose(ctx, `${ip}/name`, "item identity");
+	if (item.title !== conv.title) {
+		const t = item.title;
+		if (t === t.trim() && t.length >= 1 && t.length <= 60) node.ui.itemTitle = t;
+		else lose(ctx, `${ip}/title`, "item identity");
+	}
+}
+function ofToProd(f, shape, node, at, lv, ctx) {
+	if (shape.kind === "json" || shape.kind === "leaf" || shape.kind === "object") return lose(ctx, at, "unsupported key");
+	if (shape.kind === "modular") {
+		node.config.blockSlugs = shape.items.map((i) => kebab(i.name));
+		shape.items.forEach((item, i) => blockModelFor(item, `${at}/${i}`, ctx, node));
+		return;
+	}
+	const item = shape.item;
+	const ip = `${at}/0`;
+	if (shape.kind === "zones") {
+		const fields = item.fields ?? [];
+		node.zoned = true;
+		node.children = fields.map((c, i) => convertField(c, `${ip}/fields/${i}`, lv + 1, ctx, fields, false, ctx.lane === "props"));
+		itemIdentity(item, conventionItem(f.name, f.title, node.ui.itemLabel), node, ip, ctx);
+		for (const k of Object.keys(item)) {
+			if (item[k] === void 0) continue;
+			const p = `${ip}/${k}`;
+			if (k === "type" || k === "fields" || k === "name" || k === "title") continue;
+			if (k === "preview") node.ui.preview = previewToProd(item.preview, fields, p, ctx);
+			else if (k === "icon") {
+				const dock = f.icon === void 0 ? dockIconOf(item.icon) : void 0;
+				if (dock) node.ui.icon = dock;
+				else lose(ctx, p, "item icon");
+			} else if (k === "openMode") cat(ctx, p, "item openMode");
+			else lose(ctx, p, "item identity");
+		}
+		return;
+	}
+	if (shape.kind === "itemType") node.config.itemType = shape.itemType;
+	itemIdentity(item, conventionItem(f.name, f.title), node, ip, ctx);
+	for (const k of Object.keys(item)) {
+		if (item[k] === void 0) continue;
+		const p = `${ip}/${k}`;
+		if (k === "name" || k === "title") continue;
+		if (k === "type") {
+			if (shape.kind === "itemType" && item.type === "text") lose(ctx, p, "item settings");
+		} else if (k === "reference" && shape.kind === "refs") referenceToConfig(item.reference, node, p, ctx);
+		else lose(ctx, p, "item settings");
+	}
+}
+/**
+* A modular item type → the kind:'block' model its rows are stored against: the item title is the model name, its fields
+* the model's top-level fields. A block model holds only fields a block primitive renders; any other is not stored. The
+* item's icon and preview are how its rows read in THIS field: the field's ui.blocks, by slug.
+*/
+function blockModelFor(item, at, ctx, list) {
+	const start = ctx.lossy.length;
+	const startCat = ctx.catalog.length;
+	const slug = kebab(item.name);
+	const sub = {
+		...ctx,
+		tabs: /* @__PURE__ */ new Set(),
+		droppedTabs: /* @__PURE__ */ new Map(),
+		sets: /* @__PURE__ */ new Map()
+	};
+	const fields = item.fields ?? [];
+	const kept = [];
+	const chrome = {};
+	for (const k of Object.keys(item)) {
+		const p = `${at}/${k}`;
+		if (item[k] === void 0 || k === "type" || k === "title") continue;
+		if (k === "name") {
+			if (camel(slug) !== item.name) lose(ctx, p, "item identity");
+		} else if (k === "fields") {
+			let dropped = false;
+			let shifted = false;
+			fields.forEach((c, j) => {
+				const fp = `${p}/${j}`;
+				const mark = ctx.lossy.length;
+				const markCat = ctx.catalog.length;
+				const node = convertField(c, fp, 1, sub, fields, false);
+				if (BLOCK_FIELD_TYPES.has(node.type)) {
+					kept.push(emitField(node));
+					if (dropped && !shifted) {
+						shifted = true;
+						lose(ctx, p, "block model field");
+					}
+					return;
+				}
+				ctx.lossy.length = mark;
+				ctx.catalog.length = markCat;
+				dropped = true;
+				lose(ctx, fp, "block model field");
+			});
+		} else if (k === "openMode") cat(ctx, p, "item openMode");
+		else if (k === "icon") {
+			const dock = dockIconOf(item.icon);
+			if (dock) chrome.icon = dock;
+			else lose(ctx, p, "item icon");
+		} else if (k === "preview") chrome.preview = previewToProd(item.preview, fields, p, ctx);
+		else lose(ctx, p, "item identity");
+	}
+	const model = {
+		name: item.title,
+		slug,
+		kind: "block",
+		fields: kept
+	};
+	const prev = ctx.blockModels.get(slug);
+	const keep = () => {
+		if (!nonEmpty(chrome) || list.ui.blocks?.[slug]) return;
+		list.ui.blocks = {
+			...list.ui.blocks,
+			[slug]: chrome
+		};
+	};
+	if (!prev) {
+		ctx.blockModels.set(slug, model);
+		return keep();
+	}
+	if (deepEqual(prev, model)) return keep();
+	ctx.lossy.length = start;
+	ctx.catalog.length = startCat;
+	lose(ctx, at, "duplicate name");
+}
+function referenceToConfig(ref, node, at, ctx) {
+	const to = ref.to ?? [];
+	const entries = to.filter(ENTRY_TARGET);
+	if (entries.length < to.length) lose(ctx, entries.length || !to.length ? `${at}/to` : at, "reference target");
+	if (entries.length === 1) node.config.contentModelId = entries[0];
+	else if (entries.length > 1) Object.assign(node.config, {
+		polymorphic: true,
+		allowedModelSlugs: entries
+	});
+	if (ref.filter !== void 0) lose(ctx, `${at}/filter`, "reference filter");
+	for (const k of Object.keys(ref)) if (k !== "to" && k !== "filter") lose(ctx, `${at}/${k}`, "unsupported key");
+}
+function numericToProd(f, node, at, ctx) {
+	if (f.type !== "number" && f.type !== "rating") return lose(ctx, at, "unsupported key");
+	const n = f.numeric;
+	const lo = n.min ?? 0;
+	const hi = n.max ?? 5;
+	const st = n.step ?? 1;
+	const stops = (hi - lo) / st;
+	const ratingOk = (n.min === void 0 || Number.isFinite(n.min) && n.min >= 0) && (n.max === void 0 || isWhole(n.max, 1, 10)) && (n.step === void 0 || Number.isFinite(n.step) && n.step > 0) && lo < hi && Math.abs(stops - Math.round(stops)) < 1e-9 && Math.round(stops) <= 100;
+	for (const k of Object.keys(n)) {
+		const v = n[k];
+		if (v === void 0) continue;
+		const p = `${at}/${k}`;
+		if (k === "unit") {
+			const u = v;
+			if (f.type === "number" && typeof u === "string" && u.trim() !== "" && u.length <= 24) node.config.unit = u;
+			else lose(ctx, p, "numeric unit");
+		} else if (k === "min" || k === "max" || k === "step") if (f.type === "number") node.config[k] = v;
+		else if (ratingOk) node.config[k] = v;
+		else lose(ctx, p, "rating bounds");
+		else lose(ctx, p, "unsupported key");
+	}
+}
+var SCALE_UNIT_SET = new Set([
+	"px",
+	"%",
+	"rem",
+	"em",
+	"vw",
+	"vh"
+]);
+var unitsOk = (u) => Array.isArray(u) && u.length >= 1 && u.every((x) => SCALE_UNIT_SET.has(x));
+var boundOk = (b) => b === void 0 || typeof b === "number" && Number.isFinite(b) || isObj(b) && Object.entries(b).every(([k, x]) => SCALE_UNIT_SET.has(k) && typeof x === "number");
+var textOk = (s, max) => typeof s === "string" && s.length >= 1 && s.length <= max;
+/** A V2 scale → config.scale (numberScaleSchema): steps, units, presets and the custom escape hatch, each held to its rules. */
+function scaleToConfig(s, node, at, ctx) {
+	const steps = s.steps;
+	let outSteps;
+	if (Array.isArray(steps)) {
+		if (!(steps.length >= 1 && steps.length <= 50 && new Set(steps.map((x) => x.value)).size === steps.length && steps.every((x) => typeof x.value === "string" && x.value === x.value.trim() && textOk(x.value, 32) && textOk(x.label, 24) && (x.title === void 0 || textOk(x.title, 60)) && (x.css === void 0 || textOk(x.css, 60)) && (x.px === void 0 || typeof x.px === "number" && Number.isFinite(x.px)) && Object.keys(x).every((k) => [
+			"value",
+			"label",
+			"title",
+			"px",
+			"css"
+		].includes(k))))) return lose(ctx, at, "scale rules");
+		outSteps = steps.map((x) => ({ ...x }));
+	} else {
+		if (!(steps.min < steps.max) || steps.step !== void 0 && !(steps.step > 0)) return lose(ctx, at, "scale rules");
+		outSteps = {
+			min: steps.min,
+			max: steps.max,
+			...steps.step !== void 0 ? { step: steps.step } : {}
+		};
+	}
+	const out = { steps: outSteps };
+	const tokens = Array.isArray(steps) ? new Set(steps.map((x) => x.value)) : void 0;
+	const c = s.allowCustom;
+	const customOk = c === void 0 || typeof c === "boolean" || typeof c === "object" && c !== null && boundOk(c.min) && boundOk(c.max) && (c.units === void 0 || unitsOk(c.units)) && (c.step === void 0 || c.step > 0) && Object.keys(c).every((x) => [
+		"min",
+		"max",
+		"units",
+		"step"
+	].includes(x));
+	for (const k of Object.keys(s)) {
+		const v = s[k];
+		if (v === void 0 || k === "steps") continue;
+		const p = `${at}/${k}`;
+		if (k === "units") if (unitsOk(v)) out.units = [...v];
+		else lose(ctx, p, "scale rules");
+		else if (k === "defaultUnit") if (SCALE_UNIT_SET.has(v)) out.defaultUnit = s.defaultUnit;
+		else lose(ctx, p, "scale rules");
+		else if (k === "allowCustom") if (customOk) out.allowCustom = typeof c === "boolean" ? c : JSON.parse(JSON.stringify(c));
+		else lose(ctx, p, "scale rules");
+		else if (k === "presets") {
+			const presets = s.presets;
+			if (presets.length <= 20 && presets.every((x) => {
+				if (x.label !== void 0 && !textOk(x.label, 24)) return false;
+				if (Object.keys(x).some((y) => y !== "label" && y !== "value")) return false;
+				const pv = x.value;
+				if (typeof pv === "number") return Number.isFinite(pv);
+				if (typeof pv === "string") return textOk(pv, 32) && !!tokens?.has(pv);
+				return isObj(pv) && typeof pv.value === "number" && SCALE_UNIT_SET.has(pv.unit) && Object.keys(pv).length === 2 && customOk && !!s.allowCustom;
+			})) out.presets = presets.map((x) => ({
+				...x.label !== void 0 ? { label: x.label } : {},
+				value: typeof x.value === "object" ? { ...x.value } : x.value
+			}));
+			else lose(ctx, p, "scale rules");
+		} else lose(ctx, p, "unsupported key");
+	}
+	node.config.scale = out;
+}
+function conditionToShowIf(h, at, siblings, ctx, variantOk) {
+	const variant = variantOk && h.field === "_variant";
+	if (!h.field || !variant && !siblings.some((s) => s.name === h.field)) return void lose(ctx, at, "condition");
+	if (Object.keys(h).filter((k) => ![
+		"field",
+		"equals",
+		"notEmpty"
+	].includes(k) && h[k] !== void 0).length || h.equals !== void 0 === (h.notEmpty !== void 0)) return void lose(ctx, at, "condition");
+	if (h.notEmpty !== void 0) return h.notEmpty === true ? {
+		match: "all",
+		rules: [{
+			field: h.field,
+			op: "notEmpty"
+		}]
+	} : void lose(ctx, at, "condition");
+	const sibType = variant ? void 0 : siblings.find((s) => s.name === h.field)?.type;
+	const list = Array.isArray(h.equals) ? h.equals : [h.equals];
+	const strs = [];
+	for (const v of list) {
+		if (![
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof v)) return void lose(ctx, at, "condition");
+		const s = String(v);
+		if (coerceRuleValue(sibType, s) !== v) return void lose(ctx, at, "condition");
+		strs.push(s);
+	}
+	return {
+		match: "all",
+		rules: [Array.isArray(h.equals) ? {
+			field: h.field,
+			op: "in",
+			value: strs
+		} : {
+			field: h.field,
+			op: "eq",
+			value: strs[0]
+		}]
+	};
+}
+var nonEmpty = (o) => Object.keys(o).length ? o : void 0;
+function common(n) {
+	const out = {
+		key: n.key,
+		label: n.label,
+		type: n.type
+	};
+	for (const k of [
+		"helpText",
+		"required",
+		"defaultValue",
+		"showIf",
+		"helpMore",
+		"advanced",
+		"recommendedMax",
+		"openMode",
+		"localized"
+	]) if (n[k] !== void 0) out[k] = n[k];
+	return out;
+}
+function emitField(n) {
+	const out = common(n);
+	if (n.unique !== void 0) out.unique = n.unique;
+	if (n.readOnly !== void 0) out.readOnly = n.readOnly;
+	if (n.lockReason !== void 0) out.lockReason = n.lockReason;
+	if (n.fieldsetId !== void 0) out.fieldsetId = n.fieldsetId;
+	const config = { ...n.config };
+	if (n.placeholder !== void 0) config.placeholder = n.placeholder;
+	if (n.type === "select" && n.options) out.options = n.options;
+	if ((n.type === "multiselect" || n.type === "tags") && n.options) config.options = n.options;
+	if (n.type === "object") out.fields = (n.children ?? []).map(emitField);
+	if (n.zoned) {
+		const { minItems, maxItems, ...rest } = config;
+		out.config = {
+			...rest,
+			zones: { repeatable: {
+				fields: (n.children ?? []).map(emitField),
+				...minItems !== void 0 ? { minItems } : {},
+				...maxItems !== void 0 ? { maxItems } : {}
+			} }
+		};
+	} else if (nonEmpty(config)) out.config = config;
+	const ui = nonEmpty(n.ui);
+	if (ui) out.ui = ui;
+	return out;
+}
+function emitProp(n) {
+	const out = common(n);
+	if (n.unique !== void 0) out.unique = n.unique;
+	if (n.readOnly !== void 0) out.readOnly = n.readOnly;
+	if (n.lockReason !== void 0) out.lockReason = n.lockReason;
+	if (n.placeholder !== void 0) out.placeholder = n.placeholder;
+	const config = { ...n.config };
+	if (n.options) config.options = n.options;
+	if (n.children) config.fields = n.children.map(emitSubField);
+	if (nonEmpty(config)) out.config = config;
+	const ui = nonEmpty(n.ui);
+	if (ui) out.ui = ui;
+	return out;
+}
+function emitSubField(n) {
+	const out = common(n);
+	if (n.unique !== void 0) out.unique = n.unique;
+	if (n.readOnly !== void 0) out.readOnly = n.readOnly;
+	if (n.lockReason !== void 0) out.lockReason = n.lockReason;
+	if (n.placeholder !== void 0) out.placeholder = n.placeholder;
+	if (n.options) out.options = n.options;
+	if (n.children) out.fields = n.children.map(emitSubField);
+	if (nonEmpty(n.config)) out.config = { ...n.config };
+	const ui = nonEmpty(n.ui);
+	if (ui) out.ui = ui;
+	return out;
+}
+function fromTypeSchema(v2, target) {
+	const ctx = {
+		lane: target,
+		lossy: [],
+		catalog: [],
+		tabs: /* @__PURE__ */ new Set(),
+		droppedTabs: /* @__PURE__ */ new Map(),
+		sets: /* @__PURE__ */ new Map(),
+		propSets: /* @__PURE__ */ new Map(),
+		definedGroups: /* @__PURE__ */ new WeakMap(),
+		propOrder: /* @__PURE__ */ new Map(),
+		groupOrder: false,
+		blockModels: /* @__PURE__ */ new Map()
+	};
+	const props = target === "props";
+	const slug = kebab(v2.name);
+	const category = v2.category !== void 0 ? CATEGORY_TO_PROD[v2.category] : void 0;
+	const fieldsets = [];
+	for (const k of Object.keys(v2)) {
+		if (v2[k] === void 0) continue;
+		const p = `/${k}`;
+		switch (k) {
+			case "name":
+				if (camel(slug) !== v2.name) lose(ctx, p, "type name");
+				break;
+			case "title":
+			case "description":
+			case "fields":
+			case "fieldsets":
+			case "groups": break;
+			case "kind":
+				if (props && v2.kind !== "block") cat(ctx, p, v2.kind === "global" ? "kind:global" : "kind:entry (props)");
+				else if (!props && v2.kind !== "entry") cat(ctx, p, v2.kind === "global" ? "kind:global" : v2.kind === "page" ? "kind:page" : v2.kind === "block" ? "kind:block (fields)" : "kind:object");
+				break;
+			case "icon":
+				cat(ctx, p, "block icon");
+				break;
+			case "preview":
+				cat(ctx, p, "document preview");
+				break;
+			case "variants":
+				cat(ctx, p, "variants");
+				break;
+			case "category":
+				if (!props || !category || capitalize(category) !== v2.category) cat(ctx, p, "category");
+				break;
+			case "placement":
+				cat(ctx, p, "block placement");
+				break;
+			case "initialValue":
+				cat(ctx, p, "seeded instance");
+				break;
+			default: lose(ctx, p, "unsupported key");
+		}
+	}
+	if (props) {
+		if (v2.groups?.length) lose(ctx, "/groups", "group (props)");
+		propSetsFor(v2, ctx);
+	} else fieldsetsFor(v2, ctx, fieldsets);
+	const nodes = v2.fields.map((f, i) => convertField(f, `/fields/${i}`, 1, ctx, v2.fields, true));
+	if (props) {
+		const component = {
+			name: v2.title,
+			slug,
+			props: nodes.map(emitProp)
+		};
+		if (v2.description !== void 0) component.description = v2.description;
+		if (category) component.category = category;
+		return {
+			schema: component,
+			blockModels: [],
+			lossy: ctx.lossy,
+			catalog: ctx.catalog
+		};
+	}
+	const model = {
+		name: v2.title,
+		slug,
+		fields: nodes.map(emitField)
+	};
+	if (v2.description !== void 0) model.description = v2.description;
+	model.kind = "model";
+	if (fieldsets.length) model.fieldsets = fieldsets;
+	return {
+		schema: model,
+		blockModels: [...ctx.blockModels.values()],
+		lossy: ctx.lossy,
+		catalog: ctx.catalog
+	};
+}
+/** Fields lane: V2 groups → `kind: "tab"` fieldsets, V2 fieldsets → `kind: "group"` fieldsets in the tab their members share. */
+function fieldsetsFor(v2, ctx, out) {
+	const names = /* @__PURE__ */ new Set();
+	let firstDrop;
+	let shifted = false;
+	(v2.groups ?? []).forEach((g, i) => {
+		const p = `/groups/${i}`;
+		const stored = g.title.slice(0, 20);
+		const folded = stored.trim().toLowerCase();
+		const drop = (why) => {
+			if (!ctx.tabs.has(g.name) && !ctx.droppedTabs.has(g.name)) ctx.droppedTabs.set(g.name, why);
+			firstDrop ??= why;
+			lose(ctx, p, why);
+		};
+		if (ctx.tabs.has(g.name) || names.has(folded)) return drop("group name collision");
+		if (out.length >= 3) return drop("groups>3");
+		names.add(folded);
+		const tab = {
+			id: g.name,
+			name: stored,
+			kind: "tab"
+		};
+		if (g.title.length > 20) lose(ctx, `${p}/title`, "group name>20");
+		if (g.icon !== void 0) {
+			const dock = dockIconOf(g.icon);
+			if (dock) tab.icon = dock;
+			else lose(ctx, `${p}/icon`, "group icon");
+		}
+		if (i === 0 ? g.default !== true : g.default !== void 0) lose(ctx, `${p}/default`, "group default");
+		for (const k of Object.keys(g)) if (![
+			"name",
+			"title",
+			"icon",
+			"default"
+		].includes(k) && g[k] !== void 0) lose(ctx, `${p}/${k}`, "unsupported key");
+		ctx.tabs.add(g.name);
+		out.push(tab);
+		if (firstDrop && !shifted) {
+			shifted = true;
+			lose(ctx, "/groups", firstDrop);
+		}
+	});
+	(v2.fieldsets ?? []).forEach((fs, i) => {
+		const p = `/fieldsets/${i}`;
+		if (ctx.tabs.has(fs.name) || ctx.droppedTabs.has(fs.name) || ctx.sets.has(fs.name) || out.length >= 30) return lose(ctx, p, "fieldset collision");
+		const tally = /* @__PURE__ */ new Map();
+		for (const f of v2.fields) if (f.fieldset === fs.name) tally.set(f.group, (tally.get(f.group) ?? 0) + 1);
+		const best = [...tally.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+		const tab = best !== void 0 && ctx.tabs.has(best) ? best : void 0;
+		const set = {
+			id: fs.name,
+			name: fs.title.slice(0, 60),
+			kind: "group"
+		};
+		if (fs.title.length > 60) lose(ctx, `${p}/title`, "fieldset name>limit");
+		if (tab) set.tab = tab;
+		for (const k of Object.keys(fs)) {
+			const v = fs[k];
+			if (v === void 0 || k === "name" || k === "title") continue;
+			if (k === "description") if (v.length <= 500) set.description = v;
+			else lose(ctx, `${p}/${k}`, "help>limit");
+			else if (k === "collapsed" || k === "collapsible" || k === "columns" || k === "layout") set[k] = v;
+			else lose(ctx, `${p}/${k}`, "unsupported key");
+		}
+		ctx.sets.set(fs.name, tab);
+		out.push(set);
+	});
+}
+/**
+* Props lane: a V2 fieldset is an inline ui.group, defined on the first prop (at each level, sub-fields too) that uses
+* it. A fieldset no prop uses has nothing to be defined on; when the V2 order differs from where each group is first
+* met (depth first, a prop before its sub-fields: how propsToTypeSchema meets them), every group carries its `order`.
+*/
+function propSetsFor(v2, ctx) {
+	const sets = v2.fieldsets ?? [];
+	if (!sets.length) return;
+	const named = new Set(sets.map((s) => s.name));
+	const firstSeen = [];
+	const visit = (fields, lv) => {
+		for (const f of fields) {
+			if (f.fieldset !== void 0 && named.has(f.fieldset) && !firstSeen.includes(f.fieldset)) firstSeen.push(f.fieldset);
+			if (lv >= 10) continue;
+			const kids = previewKids(f);
+			if (kids) visit(kids, lv + 1);
+		}
+	};
+	visit(v2.fields, 1);
+	ctx.groupOrder = sets.filter((s) => firstSeen.includes(s.name)).some((s, i) => s.name !== firstSeen[i]);
+	let gap = false;
+	sets.forEach((s, i) => {
+		ctx.propSets.set(s.name, s);
+		ctx.propOrder.set(s.name, i);
+		if (!firstSeen.includes(s.name)) {
+			gap = true;
+			return lose(ctx, `/fieldsets/${i}`, "fieldset (props)");
+		}
+		if (gap) {
+			gap = false;
+			lose(ctx, "/fieldsets", "fieldset (props)");
+		}
+		for (const k of Object.keys(s)) {
+			if (s[k] === void 0 || k === "name" || k === "collapsed" || k === "columns" || k === "collapsible" || k === "layout") continue;
+			if (k === "title") {
+				if (s.title.length > 32) lose(ctx, `/fieldsets/${i}/title`, "fieldset name>limit");
+			} else if (k === "description") {
+				if (!groupDescriptionOk(s.description)) lose(ctx, `/fieldsets/${i}/description`, "help>limit");
+			} else lose(ctx, `/fieldsets/${i}/${k}`, "unsupported key");
+		}
+	});
+}
+function readField(f) {
+	const cfg = { ...f.config ?? {} };
+	const n = {
+		...f,
+		config: cfg,
+		ui: { ...f.ui ?? {} }
+	};
+	if (typeof cfg.placeholder === "string") {
+		n.placeholder = cfg.placeholder;
+		delete cfg.placeholder;
+	}
+	if (n.placeholder === void 0 && typeof n.ui.placeholder === "string") n.placeholder = n.ui.placeholder;
+	delete n.ui.placeholder;
+	if ((f.type === "multiselect" || f.type === "tags") && cfg.options) {
+		n.options = cfg.options;
+		delete cfg.options;
+	}
+	n.fields = f.fields?.map(readField);
+	if (cfg.zones) {
+		const z = cfg.zones;
+		n.zones = {
+			...z.nonRepeatable ? { nonRepeatable: z.nonRepeatable.map(readField) } : {},
+			...z.repeatable ? { repeatable: {
+				...z.repeatable,
+				fields: z.repeatable.fields.map(readField)
+			} } : {}
+		};
+		delete cfg.zones;
+	}
+	return n;
+}
+function readProp(p) {
+	const { config, fields, options, ...rest } = p;
+	const cfg = { ...config ?? {} };
+	const n = {
+		...rest,
+		config: cfg,
+		ui: { ...p.ui ?? {} }
+	};
+	const opts = cfg.options ?? options;
+	if (opts) n.options = opts;
+	delete cfg.options;
+	const kids = cfg.fields ?? fields;
+	if (kids) n.fields = kids.map(readProp);
+	delete cfg.fields;
+	return n;
+}
+/** A stored choice → the V2 option: a dock icon reads back as the kit's Tabler name, the description as itself. */
+var optionsFromProd = (opts) => opts.map((o) => {
+	if (typeof o === "string") return {
+		value: o,
+		label: o
+	};
+	const out = {
+		value: o.value,
+		label: o.label
+	};
+	if (typeof o.icon === "string") out.icon = tablerIconOf(o.icon);
+	if (typeof o.description === "string") out.description = o.description;
+	return out;
+});
+function scaleFromConfig(s, at, ctx) {
+	const steps = s.steps;
+	const out = !Array.isArray(steps) ? { steps: {
+		min: steps.min,
+		max: steps.max,
+		...steps.step !== void 0 ? { step: steps.step } : {}
+	} } : steps.some((x) => typeof x.value === "string") ? { steps: steps.map((x) => ({ ...x })) } : (ctx.onLoss(`${at}/steps`, "scale steps", "Numeric step lists read back as token steps named by their number."), { steps: steps.map((x) => ({
+		value: String(x.value),
+		label: x.label ?? String(x.value),
+		px: x.value
+	})) });
+	if (s.units) out.units = s.units;
+	if (s.defaultUnit) out.defaultUnit = s.defaultUnit;
+	if (s.allowCustom !== void 0) out.allowCustom = isObj(s.allowCustom) ? JSON.parse(JSON.stringify(s.allowCustom)) : s.allowCustom;
+	if (s.presets) out.presets = s.presets.map((p) => ({
+		...p.label !== void 0 ? { label: p.label } : {},
+		value: typeof p.value === "object" ? { ...p.value } : p.value
+	}));
+	return out;
+}
+/** The prod children a preview path segment may name below a node (an object's, a list's rows'), or null for a leaf. */
+var readKids = (n) => n.zones ? [...n.zones.nonRepeatable ?? [], ...n.zones.repeatable?.fields ?? []] : n.fields && [
+	"object",
+	"group",
+	"repeater",
+	"table"
+].includes(n.type) ? n.fields : null;
+/** A stored preview path → the V2 path: `image.altText` reads as `image.alt`, the rest as it is. */
+function previewPathFromProd(path, children) {
+	const segs = path.split(".");
+	let node = children.find((c) => c.key === segs[0]);
+	for (let i = 1; node && i < segs.length; i++) {
+		const kids = readKids(node);
+		if (kids) {
+			node = kids.find((c) => c.key === segs[i]);
+			continue;
+		}
+		if (node.type === "image") {
+			const back = Object.entries(IMAGE_PATH_KEY).find(([, stored]) => stored === segs[i])?.[0];
+			if (back) segs[i] = back;
+		}
+		break;
+	}
+	return segs.join(".");
+}
+function previewFromProd(pv, children) {
+	const out = { ...pv };
+	for (const k of [
+		"title",
+		"subtitle",
+		"media"
+	]) if (typeof pv[k] === "string") out[k] = previewPathFromProd(pv[k], children);
+	if (typeof pv.icon === "string") out.icon = tablerIconOf(pv.icon);
+	return out;
+}
+function showIfToCondition(s, siblings, at, ctx) {
+	const drop = (why) => void ctx.onLoss(at, "condition", why);
+	if (s.rules.length !== 1) return drop("V2 conditions test one sibling; a multi-rule showIf is dropped (the field always shows).");
+	const r = s.rules[0];
+	const sib = siblings.find((x) => x.key === r.field);
+	const t = sib?.type === "number" ? "number" : sib?.type;
+	const read = (v) => coerceRuleValue(t, v);
+	switch (r.op) {
+		case "eq": return Array.isArray(r.value) ? {
+			field: r.field,
+			equals: r.value.map(read)
+		} : {
+			field: r.field,
+			equals: read(r.value ?? "")
+		};
+		case "in": return {
+			field: r.field,
+			equals: (Array.isArray(r.value) ? r.value : [r.value ?? ""]).map(read)
+		};
+		case "isSet":
+		case "notEmpty": return {
+			field: r.field,
+			notEmpty: true
+		};
+		default: return drop(`V2 conditions have no "${r.op}"; the field always shows.`);
+	}
+}
+function v2Type(n, at, ctx) {
+	switch (n.type) {
+		case "text": return n.config.inputType === "url" ? "url" : "string";
+		case "longtext": return "text";
+		case "document":
+			ctx.onLoss(`${at}/type`, "document", "A document (article body) reads as rich text.");
+			return "richtext";
+		case "phone":
+			ctx.onLoss(`${at}/type`, "phone", "V2 has no phone type; it reads as a string.");
+			return "string";
+		case "location": return "geopoint";
+		case "number": return n.ui.control === "rating" ? "rating" : "number";
+		case "select": return n.config.multiSelect === true ? "multiselect" : "select";
+		case "multiselect": return n.config.allowCustom === true ? "tags" : "multiselect";
+		case "group":
+		case "object": return "object";
+		case "repeater":
+		case "table":
+		case "array":
+		case "multi-reference":
+		case "multiReference":
+		case "modular": return "array";
+		case "form": return "reference";
+		case "component-ref":
+		case "sections":
+		case "slot":
+			ctx.onLoss(`${at}/type`, n.type, "This prod type stores component or block instances V2 cannot edit; it reads as json.");
+			return "json";
+		default: return n.type;
+	}
+}
+function readToV2(n, at, siblings, ctx, top, lane) {
+	/** a data-table prop (config.mode "data") holds one TableValue: the V2 `table` field, not a list of rows */
+	const dataTable = lane === "props" && isDataTableProp(n);
+	const type = dataTable ? "table" : v2Type(n, at, ctx);
+	const f = {
+		name: n.key,
+		title: n.label,
+		type
+	};
+	const cfg = n.config;
+	const val = {};
+	const loss = (k, feature, reason) => ctx.onLoss(`${at}/${k}`, feature, reason);
+	if (n.helpText !== void 0) f.description = n.helpText;
+	if (n.helpMore !== void 0) f.helpMore = n.helpMore;
+	if (n.placeholder !== void 0) f.placeholder = n.placeholder;
+	if (n.required !== void 0) val.required = n.required;
+	if (n.unique !== void 0) val.unique = n.unique;
+	if (n.recommendedMax !== void 0) val.recommendedMax = n.recommendedMax;
+	if (n.advanced !== void 0) f.advanced = n.advanced;
+	if (n.openMode !== void 0) f.openMode = n.openMode;
+	if (n.readOnly === true) f.readOnly = true;
+	if (n.ui.access) f.access = { ...n.ui.access };
+	else if (n.readOnly === "developer") f.access = { edit: "schema.manage" };
+	if (n.lockReason !== void 0) f.lockReason = n.lockReason;
+	if (n.localized !== void 0) f.localized = n.localized;
+	if (n.ui.hidden !== void 0) f.hidden = n.ui.hidden;
+	if (n.ui.rows !== void 0) f.rows = n.ui.rows;
+	if (n.ui.synced !== void 0) f.synced = { ...n.ui.synced };
+	if (n.ui.valueShape !== void 0) f.valueShape = n.ui.valueShape;
+	if (n.showIf) {
+		const c = showIfToCondition(n.showIf, siblings, `${at}/showIf`, ctx);
+		if (c) f.hidden = c;
+	}
+	if (n.placement !== void 0) loss("placement", "placement", "V2 has no editor placement; the field renders in the form.");
+	if (n.searchable === false) loss("searchable", "searchable", "V2 has no search-index flag.");
+	if (n.ui.collapsed !== void 0) loss("ui/collapsed", "ui.collapsed", "V2 fields have no start-collapsed flag.");
+	if (n.ui.reorderable !== void 0) loss("ui/reorderable", "ui.reorderable", "V2 lists are always reorderable.");
+	if (n.ui.input !== void 0) loss("ui/input", "ui.input", "Custom dock inputs are a dock feature V2 has no key for.");
+	if (n.fieldsetId !== void 0) {
+		const set = ctx.sets.get(n.fieldsetId);
+		if (set?.kind === "tab") if (top) f.group = set.id;
+		else loss("fieldsetId", "fieldset", "Only top-level V2 fields sit in a tab; this nested field's tab is dropped.");
+		else if (set) {
+			f.fieldset = set.id;
+			if (top && set.tab !== void 0) f.group = set.tab;
+		} else loss("fieldsetId", "fieldset", `No fieldset "${n.fieldsetId}" exists on this model; the membership is dropped.`);
+	}
+	if (lane === "props" && n.ui.group) f.fieldset = n.ui.group.id;
+	for (const k of [
+		"target",
+		"stale",
+		"origin"
+	]) if (n[k] !== void 0) loss(k, k, k === "target" ? "A prop's target (where it writes in the component) is binding, not schema: V2 has no key for it, so the host keeps it." : `V2 has no "${k}" key.`);
+	const used = new Set([
+		"placeholder",
+		"zones",
+		"options",
+		"fields"
+	]);
+	const usedUi = new Set([
+		"collapsed",
+		"reorderable",
+		"input",
+		"access",
+		"hidden",
+		"rows",
+		"synced",
+		"valueShape"
+	]);
+	const use = (...k) => k.forEach((x) => used.add(x));
+	const useUi = (...k) => k.forEach((x) => usedUi.add(x));
+	if (lane === "props") useUi("group");
+	if ([
+		"text",
+		"longtext",
+		"url",
+		"richtext",
+		"document"
+	].includes(n.type)) {
+		use("minLength", "maxLength", "pattern", "patternMessage", "inputType");
+		if (typeof cfg.minLength === "number") val.min = cfg.minLength;
+		if (typeof cfg.maxLength === "number") val.max = cfg.maxLength;
+		if (typeof cfg.pattern === "string") val.pattern = cfg.pattern;
+		if (typeof cfg.patternMessage === "string") val.patternMessage = cfg.patternMessage;
+	}
+	if (type === "number" || type === "rating") {
+		const numeric = {};
+		for (const k of [
+			"min",
+			"max",
+			"step"
+		]) if (typeof cfg[k] === "number") numeric[k] = cfg[k];
+		const ratingDefault = type === "rating" && n.type === "number" && ratingIsDefault(numeric);
+		if (typeof cfg.unit === "string") numeric.unit = cfg.unit;
+		if (Object.keys(numeric).length && !ratingDefault) f.numeric = numeric;
+		const bounds = cfg.validation;
+		if (isObj(bounds)) {
+			for (const k of ["min", "max"]) if (typeof bounds[k] === "number") val[k] = bounds[k];
+		}
+		if (cfg.scale) f.scale = scaleFromConfig(cfg.scale, `${at}/config/scale`, ctx);
+		if (n.ui.control === "slider") f.layout = "slider";
+		use("min", "max", "step", "scale", "unit", "validation");
+		if (n.ui.control === "slider" || n.ui.control === "rating") useUi("control");
+	}
+	const control = n.ui.control;
+	if (control !== void 0 && control !== "slider" && control !== "rating" && (control === "segmented" ? type === "select" : CONTROL_TYPES[control]?.includes(type))) {
+		f.layout = control;
+		useUi("control");
+	}
+	if (n.type === "select") use("multiSelect");
+	if ((type === "select" || type === "multiselect" || type === "tags") && n.options) f.options = optionsFromProd(n.options);
+	if (type === "multiselect" || type === "tags") {
+		if (typeof cfg.min === "number") val.min = cfg.min;
+		if (typeof cfg.max === "number") val.max = cfg.max;
+		use("min", "max", "allowCustom");
+	}
+	if (n.type === "code") {
+		if (typeof cfg.language === "string") f.language = cfg.language;
+		else if (cfg.language !== void 0) loss("config/language", "code language", "The field's language is not a string; it is dropped.");
+		if (Array.isArray(cfg.languages) && cfg.languages.every((l) => typeof l === "string")) f.languages = [...cfg.languages];
+		else if (cfg.languages !== void 0) loss("config/languages", "code language", "The field's languages are not a list of names; they are dropped.");
+		use("language", "languages");
+	}
+	if (n.type === "tags" && cfg.allowCustom === false) loss("config/allowCustom", "tags closed", "V2 tags always take free entry; a closed tags list reads as open tags.");
+	if (type === "date" || type === "datetime") use("timezone", "includeTime");
+	if ((type === "date" || type === "datetime") && typeof cfg.timezone === "string") f.timezone = cfg.timezone === "site" ? "site" : `fixed:${cfg.timezone}`;
+	if ((type === "date" || type === "datetime") && typeof cfg.timezone === "boolean") f.timezone = cfg.timezone;
+	if (n.type === "reference" || n.type === "multi-reference" || n.type === "multiReference") use("contentModelId", "polymorphic", "allowedModelSlugs");
+	if (n.type === "reference") {
+		const to = cfg.polymorphic ? cfg.allowedModelSlugs ?? [] : cfg.contentModelId ? [cfg.contentModelId] : [];
+		if (to.length) f.reference = { to };
+	}
+	if (n.type === "form") f.reference = { to: ["form"] };
+	if (n.type === "object" || n.type === "group") {
+		f.fields = (n.fields ?? []).map((c, i) => readToV2(c, `${at}/fields/${i}`, n.fields ?? [], ctx, false, lane));
+		if (n.ui.preview) f.preview = previewFromProd(n.ui.preview, n.fields ?? []);
+		if (n.ui.icon) f.icon = tablerIconOf(n.ui.icon);
+		useUi("preview", "icon");
+	}
+	if (n.type === "array" && n.zones?.nonRepeatable) {
+		const nr = n.zones.nonRepeatable;
+		const kids = [{
+			name: "nonRepeatable",
+			title: n.label,
+			type: "object",
+			fields: nr.map((c, i) => readToV2(c, `${at}/config/zones/nonRepeatable/${i}`, nr, ctx, false, lane))
+		}];
+		if (n.zones.repeatable) kids.push(listOf(n, n.zones.repeatable.fields, "repeatable", `${at}/config/zones/repeatable`, ctx, lane));
+		ctx.onLoss(`${at}/config/zones`, "zone envelope", "A non-repeatable zone reads as an object with nonRepeatable (and repeatable) children, matching its stored {nonRepeatable, repeatable} value.");
+		Object.assign(f, {
+			type: "object",
+			fields: kids
+		});
+	} else if (dataTable) {
+		f.table = tableOptionsFromConfig(cfg);
+		use("mode", "columnTypes", "lockColumns", "requireCaption", "allowGroups", "allowFootnotes", "allowNote", "minRows", "maxRows", "maxColumns", "settings", "jsonLd");
+	} else if (n.type === "array" && n.zones?.repeatable || n.type === "repeater" || n.type === "table") {
+		const list = listOf(n, n.zones?.repeatable?.fields ?? n.fields ?? [], n.key, at, ctx, lane);
+		useUi("preview", "icon", "itemLabel", "layout", "itemName", "itemTitle");
+		if (n.zones?.repeatable) ctx.zoned.add(f);
+		f.of = list.of;
+		if (list.itemNoun !== void 0) f.itemNoun = list.itemNoun;
+		if (list.arrayLayout) f.arrayLayout = list.arrayLayout;
+		if (list.layout) f.layout = list.layout;
+		const r = n.zones?.repeatable ?? (n.type === "table" ? {
+			minItems: cfg.minItems,
+			maxItems: cfg.maxItems
+		} : void 0);
+		if (typeof r?.minItems === "number") val.min = r.minItems;
+		if (typeof r?.maxItems === "number") val.max = r.maxItems;
+		if (n.type === "table") use("minItems", "maxItems");
+	} else if (n.type === "array" && cfg.itemType) {
+		f.of = [{
+			...itemOf(n),
+			type: cfg.itemType === "text" ? "string" : cfg.itemType
+		}];
+		leafListChrome(n, f, loss, "a list of scalars");
+		if (typeof cfg.minItems === "number") val.min = cfg.minItems;
+		if (typeof cfg.maxItems === "number") val.max = cfg.maxItems;
+		use("itemType", "minItems", "maxItems");
+		useUi("layout", "itemLabel", "itemName", "itemTitle");
+	} else if (n.type === "modular") {
+		const slugs = cfg.blockSlugs ?? [];
+		f.of = slugs.map((s, j) => {
+			const bm = ctx.blockModels.get(s);
+			const chrome = n.ui.blocks?.[s];
+			const kids = bm ? bm.fields.map(readField) : [];
+			const item = bm ? {
+				name: camel(s),
+				title: bm.name,
+				type: "object",
+				fields: kids.map((c, k) => readToV2(c, `${at}/of/${j}/fields/${k}`, kids, ctx, false, lane))
+			} : {
+				name: camel(s),
+				title: camel(s),
+				type: "object",
+				fields: []
+			};
+			if (chrome?.icon) item.icon = tablerIconOf(chrome.icon);
+			if (chrome?.preview) item.preview = previewFromProd(chrome.preview, kids);
+			return item;
+		});
+		const missing = slugs.filter((s) => !ctx.blockModels.has(s));
+		if (missing.length) ctx.onLoss(`${at}/config/blockSlugs`, "block models", `Each item type is its own block model; ${missing.join(", ")} was not passed, so its fields read as none.`);
+		ctx.modular.add(f);
+		if (n.ui.itemLabel) f.itemNoun = n.ui.itemLabel.toLowerCase();
+		if (n.ui.icon) f.icon = tablerIconOf(n.ui.icon);
+		const l = n.ui.layout;
+		if (l === "grid" || l === "list") f.arrayLayout = l;
+		else if (l === "rows") f.layout = "list";
+		else if (l) loss("ui/layout", "ui.layout", `V2 has no "${l}" layout for a list of blocks.`);
+		if (typeof cfg.minItems === "number") val.min = cfg.minItems;
+		if (typeof cfg.maxItems === "number") val.max = cfg.maxItems;
+		use("blockSlugs", "minItems", "maxItems");
+		useUi("itemLabel", "icon", "layout", "blocks");
+	} else if (n.type === "multi-reference" || n.type === "multiReference") {
+		const to = cfg.polymorphic ? cfg.allowedModelSlugs ?? [] : cfg.contentModelId ? [cfg.contentModelId] : [];
+		f.of = [{
+			...itemOf(n),
+			type: "reference",
+			...to.length ? { reference: { to } } : {}
+		}];
+		leafListChrome(n, f, loss, "a list of entries");
+		if (typeof cfg.min === "number") val.min = cfg.min;
+		if (typeof cfg.max === "number") val.max = cfg.max;
+		use("min", "max");
+		useUi("layout", "itemLabel", "itemName", "itemTitle");
+	}
+	if (n.type === "array" && n.zones?.nonRepeatable && n.zones.repeatable) useUi("preview", "icon", "itemLabel", "layout");
+	for (const [k, x] of Object.entries(cfg)) if (x !== void 0 && !used.has(k)) loss(`config/${k}`, "config", `V2 has no "${k}" setting on a ${type} field.`);
+	for (const [k, x] of Object.entries(n.ui)) if (x !== void 0 && !usedUi.has(k)) loss(`ui/${k}`, `ui.${k}`, `V2 has no ui.${k} on a ${type} field.`);
+	if (n.defaultValue !== void 0 || top && ctx.plans) {
+		const plan = readPlan(f, n.type, ctx.zoned, ctx.modular);
+		if (top) ctx.plans?.set(f.name, plan);
+		if (n.defaultValue !== void 0) f.initialValue = planFromProd(plan, n.defaultValue, (rel, reason) => loss(`defaultValue${rel}`, "stored value", reason));
+	}
+	if (Object.keys(val).length) f.validation = val;
+	return f;
+}
+/** A list of scalars or entries: its item's name and title (ui.itemName / ui.itemTitle, else the convention). */
+var itemOf = (n) => {
+	const conv = conventionItem(n.key, n.label);
+	return {
+		name: n.ui.itemName ?? conv.name,
+		title: n.ui.itemTitle ?? conv.title
+	};
+};
+/** A list of scalars or entries: the noun (ui.itemLabel) and its layout (rows → list, gallery → grid tiles). */
+function leafListChrome(n, f, loss, what) {
+	if (n.ui.itemLabel !== void 0) f.itemNoun = n.ui.itemLabel.toLowerCase();
+	const l = n.ui.layout;
+	if (l === "rows") f.layout = "list";
+	else if (l === "gallery") f.arrayLayout = "grid";
+	else if (l) loss("ui/layout", "ui.layout", `V2 has no "${l}" layout for ${what}.`);
+}
+/** A list of object rows (zones.repeatable, legacy repeater, prop table) → the V2 array's single item type. */
+function listOf(n, kids, name, at, ctx, lane) {
+	const conv = conventionItem(name, n.label, n.ui.itemLabel);
+	const item = {
+		name: n.ui.itemName ?? conv.name,
+		title: n.ui.itemTitle ?? conv.title,
+		type: "object",
+		fields: kids.map((c, i) => readToV2(c, `${at}/fields/${i}`, kids, ctx, false, lane))
+	};
+	if (n.ui.preview) item.preview = previewFromProd(n.ui.preview, kids);
+	if (n.ui.icon) item.icon = tablerIconOf(n.ui.icon);
+	const out = {
+		name,
+		title: n.label,
+		type: "array",
+		of: [item]
+	};
+	if (n.ui.itemLabel !== void 0) out.itemNoun = n.ui.itemLabel.toLowerCase();
+	const l = n.ui.layout;
+	if (l === "grid" || l === "list") out.arrayLayout = l;
+	else if (l === "rows") out.layout = "list";
+	else if (l) ctx.onLoss(`${at}/ui/layout`, "ui.layout", `V2 has no "${l}" layout for rows.`);
+	return out;
+}
+/** A prod content model (both dialects) → TypeSchema. */
+function toTypeSchema(model, opts = {}) {
+	const ctx = {
+		onLoss: (path, feature, reason) => opts.onLoss?.({
+			path,
+			feature,
+			reason
+		}),
+		sets: /* @__PURE__ */ new Map(),
+		zoned: /* @__PURE__ */ new WeakSet(),
+		modular: /* @__PURE__ */ new WeakSet(),
+		blockModels: new Map((opts.blockModels ?? []).map((m) => [m.slug, m])),
+		plans: opts.plans
+	};
+	const sets = model.fieldsets ?? [];
+	const groups = [];
+	const fieldsets = [];
+	sets.forEach((s, i) => {
+		ctx.sets.set(s.id, s);
+		if (s.kind === "tab") {
+			const g = {
+				name: s.id,
+				title: s.name
+			};
+			if (s.icon) g.icon = tablerIconOf(s.icon);
+			if (groups.length === 0) g.default = true;
+			groups.push(g);
+			return;
+		}
+		const fs = {
+			name: s.id,
+			title: s.name
+		};
+		if (s.description !== void 0) fs.description = s.description;
+		for (const k of [
+			"collapsed",
+			"collapsible",
+			"columns",
+			"layout"
+		]) if (s[k] !== void 0) fs[k] = s[k];
+		if (s.kind === "row") ctx.onLoss(`/fieldsets/${i}/kind`, "fieldset row", "V2 has no row fieldset; it reads as a section.");
+		if (s.icon !== void 0) ctx.onLoss(`/fieldsets/${i}/icon`, "fieldset icon", "V2 sections have no icon.");
+		fieldsets.push(fs);
+	});
+	const nodes = model.fields.map(readField);
+	const out = {
+		name: camel(model.slug),
+		title: model.name,
+		kind: model.kind === "block" ? "block" : "entry",
+		fields: nodes.map((n, i) => readToV2(n, `/fields/${i}`, nodes, ctx, true, "fields"))
+	};
+	if (model.description !== void 0) out.description = model.description;
+	if (fieldsets.length) out.fieldsets = fieldsets;
+	if (groups.length) out.groups = groups;
+	return out;
+}
+/** A prod component's props → TypeSchema (kind "block"); prop groups read back as fieldsets. */
+function propsToTypeSchema(component, opts = {}) {
+	const ctx = {
+		onLoss: (path, feature, reason) => opts.onLoss?.({
+			path,
+			feature,
+			reason
+		}),
+		sets: /* @__PURE__ */ new Map(),
+		zoned: /* @__PURE__ */ new WeakSet(),
+		modular: /* @__PURE__ */ new WeakSet(),
+		blockModels: new Map((opts.blockModels ?? []).map((m) => [m.slug, m])),
+		plans: opts.plans
+	};
+	const nodes = component.props.map(readProp);
+	const fieldsets = [];
+	const order = /* @__PURE__ */ new Map();
+	const visit = (list, at) => list.forEach((n, i) => {
+		const g = n.ui.group;
+		if (g && !fieldsets.some((s) => s.name === g.id)) {
+			const fs = {
+				name: g.id,
+				title: g.label ?? g.id
+			};
+			if (g.description !== void 0) fs.description = g.description;
+			if (g.collapsed !== void 0) fs.collapsed = g.collapsed;
+			if (g.columns !== void 0) fs.columns = g.columns;
+			if (g.collapsible !== void 0) fs.collapsible = g.collapsible;
+			if (g.layout !== void 0) fs.layout = g.layout;
+			if (typeof g.order === "number") order.set(g.id, g.order);
+			if (g.kind === "row") ctx.onLoss(`${at}/${i}/ui/group/kind`, "fieldset row", "V2 has no row fieldset; it reads as a section.");
+			if (g.icon !== void 0) ctx.onLoss(`${at}/${i}/ui/group/icon`, "fieldset icon", "V2 sections have no icon.");
+			fieldsets.push(fs);
+		}
+		if (n.fields) visit(n.fields, `${at}/${i}/fields`);
+	});
+	visit(nodes, "/fields");
+	if (order.size) {
+		const at = new Map(fieldsets.map((s, i) => [s.name, i]));
+		fieldsets.sort((a, b) => (order.get(a.name) ?? at.get(a.name)) - (order.get(b.name) ?? at.get(b.name)));
+	}
+	const out = {
+		name: camel(component.slug),
+		title: component.name,
+		kind: "block",
+		fields: nodes.map((n, i) => readToV2(n, `/fields/${i}`, nodes, ctx, true, "props"))
+	};
+	if (component.description !== void 0 && component.description !== null) out.description = component.description;
+	if (component.category !== void 0 && component.category !== "custom") out.category = capitalize(component.category);
+	if (fieldsets.length) out.fieldsets = fieldsets;
+	return out;
+}
+//#endregion
+export { CATEGORY_TO_PROD, fromTypeSchema, leafValuePlan, planFromProd, planToProd, propsToTypeSchema, toTypeSchema };
+
+//# sourceMappingURL=schema.js.map