@bettercms-ai/kit 0.1.1 → 2.0.0

package/dist/adapters/schema.js

@@ -0,0 +1,3020 @@
+import { CATALOG, FEATURES, isHostConfigKey } from "./lossy.js";
+import { CONTROL_TYPES, HELP_MORE_MAX, ITEM_NAME_RE, UI_CONTROLS } from "./prod-types.js";
+import { dockIconOf, tablerIconOf } from "./icons.js";
+import { slotChildrenFromStored, slotChildrenToStored } from "../controls/slot-services.js";
+import { isDataTableProp, tableConfigFromOptions, tableOptionsFromConfig } from "../controls/table/prod.js";
+import { buttonFromProd, buttonToProd, datetimeFromProd, datetimeToProd, imageFromProd, imageToProd, isCropRect, linkFromProd, linkToProd, listFromProd, listToProd, ratingFromProd, ratingToProd, referenceFromProd, referenceToProd, scaleFromProd, scaleToProd, typedRowsFromProd, typedRowsToProd, videoFromProd, videoToProd, zoneListFromProd, zoneListToProd } from "./values.js";
+//#region src/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());
+/** The slug a V2 schema name is stored under (a component's, when the host seeds a /kit block): `textBlock` → `text-block`. */
+var schemaSlugOf = kebab;
+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 = /* @__PURE__ */ new Set([
+	"array",
+	"reference",
+	"multi-reference",
+	"multiReference",
+	"date",
+	"datetime",
+	"component-ref",
+	"modular",
+	"sections",
+	"tags",
+	"rating",
+	"code",
+	"video",
+	"table",
+	"slot"
+]);
+/** 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 non-entry targets a prop reference stores in config.targets (backend reference-target-config.ts REF_TARGET_KINDS). */
+var REF_TARGET_KINDS = [
+	"page",
+	"form",
+	"collection"
+];
+/**
+* A prop reference whose only target is Shopify (backend reference-target-config.ts UNSUPPORTED_TARGETS refuses it by
+* name) is stored as locked text holding the id (a list of them: a list of text), so the value stays the plain gid
+* string V2 holds. This lock reason is the marker the read side turns back into V2's reference (allowed deviation
+* "shopify reference").
+*/
+var SHOPIFY_REF_LOCK = "A Shopify product id. No Shopify integration backs a reference in BetterCMS yet, so the id is kept as it is.";
+var shopifyOnly = (r) => !!r?.to?.length && r.to.every((t) => t === "shopify");
+/** backend REFERENCE_FILTER_MAX; parameters ($x) and the parent document (^) are refused there (reference_filter_invalid). */
+var REFERENCE_FILTER_MAX = 500;
+var filterKept = (f) => typeof f === "string" && f.trim() !== "" && f.length <= REFERENCE_FILTER_MAX && !/[$^]/.test(f);
+/** 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
+};
+/**
+* A V2 rating sets no step and holds any number on its scale (a 4.8 average). Prod's unset step is 1, which refuses
+* 4.8 (rating_value_invalid), so a rating with no step is written with step 0.1 (≤ RATING_MAX_STOPS stops on a 1–10
+* scale) and that step reads back as none; a prod rating with no step reads back as its real step, 1.
+*/
+var V2_RATING_STEP = .1;
+/**
+* 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 = /* @__PURE__ */ new Set([
+	"text",
+	"longtext",
+	"richtext",
+	"image",
+	"link",
+	"slug",
+	"email",
+	"phone",
+	"color",
+	"select",
+	"number",
+	"rating",
+	"date",
+	"datetime",
+	"boolean"
+]);
+/** A slot prop's config.minItems / maxItems cap (SLOT_ITEMS_CAP, componentPropDefSchema). */
+var SLOT_ITEMS_CAP = 50;
+/** A table prop's rows and an array prop's items: their config.minItems / maxItems cap (LIST_ITEMS_CAP). */
+var LIST_ITEMS_CAP = 500;
+/** backend slotAllowIssues: a slot's config.allow holds 1–50 block names of 1–64 characters, no repeats. */
+var SLOT_ALLOW_MAX = 50;
+var SLOT_ALLOW_NAME_MAX = 64;
+/** 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set([
+	"multiselect",
+	"tags",
+	"multi-reference",
+	"table",
+	"array"
+]);
+var UNIQUE_ROW_PROPS = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set([
+	"text",
+	"longtext",
+	"richtext",
+	"document"
+]);
+var LENGTH_PROPS = /* @__PURE__ */ new Set([
+	"text",
+	"url",
+	"longtext",
+	"richtext"
+]);
+var PATTERN_TYPES = /* @__PURE__ */ 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 = /* @__PURE__ */ 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" };
+/** The keys of a data table's value a preview path may end on (previewPathProblem `<table>.caption` / `.notes`). */
+var TABLE_PATH_KEYS = ["caption", "notes"];
+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 = /* @__PURE__ */ new Set([
+	"name",
+	"title",
+	"type",
+	"description",
+	"helpMore",
+	"initialValue",
+	"validation",
+	"fieldset",
+	"group",
+	"hidden",
+	"readOnly",
+	"access",
+	"lockReason",
+	"advanced",
+	"localized",
+	"ai",
+	"placeholder",
+	"archived"
+]);
+/** Types a slot setting may not be (backend slotSettingsHardening, and a model slot's SLOT_SETTINGS_NESTING: leaf fields only). */
+var SETTING_NESTING_TYPES = /* @__PURE__ */ new Set([
+	"object",
+	"group",
+	"array",
+	"table",
+	"slot",
+	"form",
+	"modular"
+]);
+/** backend slotSettingsHardening: at most this many per-child settings. */
+var SLOT_SETTINGS_MAX = 20;
+/** backend ITEM_TYPE_NAME (what a row's `_type` holds), and an item type label's cap. */
+var ITEM_TYPE_NAME = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+var ITEM_TYPE_LABEL_MAX = 120;
+function shapeOf(f, lv, ctx, top, nest) {
+	const shape = shapeOfField(f, lv, ctx, top);
+	if (nest === "setting" && SETTING_NESTING_TYPES.has(shape.type)) return {
+		kind: "json",
+		type: "json",
+		feature: "slotSettings"
+	};
+	return shape;
+}
+/** backend content.ts keyRuleProblem: keys a resolver would misread (KEY_RESERVED), and a key's format (KEY_FORMAT). */
+var MODEL_RESERVED_KEYS = /* @__PURE__ */ new Set([
+	"derived",
+	"layout",
+	"page"
+]);
+/** The key a model field is stored under: a reserved or malformed V2 name, renamed. */
+function modelKeyOf(name) {
+	let k = name.replace(/^_+/, "").replace(/[^A-Za-z0-9_-]/g, "");
+	if (!/^[A-Za-z]/.test(k)) k = `f${k}`;
+	return MODEL_RESERVED_KEYS.has(k) ? `${k}Field` : k;
+}
+/** A slot's V2 allow list as the backend keeps it: 1–50 distinct block names of 1–64 characters (slotAllowIssues). */
+var slotAllowOk = (allow) => Array.isArray(allow) && allow.length >= 1 && allow.length <= SLOT_ALLOW_MAX && new Set(allow).size === allow.length && allow.every((n) => typeof n === "string" && n === n.trim() && n.length >= 1 && n.length <= SLOT_ALLOW_NAME_MAX);
+function shapeOfField(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 names a content model or a page / form / collection target (refTargetNamed): with none it is stored as json */
+	const noEntry = (r) => props && !(r?.to ?? []).some((t) => ENTRY_TARGET(t) || REF_TARGET_KINDS.includes(t));
+	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 && of.every((i) => i.type === "object")) {
+				if (!props) return {
+					kind: "modular",
+					type: "modular",
+					items: of
+				};
+				return deep ? {
+					kind: "json",
+					type: "json",
+					feature: "depth>10"
+				} : {
+					kind: "types",
+					type: "table",
+					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" && shopifyOnly(item.reference)) return {
+				kind: "itemType",
+				type: "array",
+				item,
+				itemType: "text",
+				shopify: true
+			};
+			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":
+			if (!props && !slotAllowOk(f.of?.allow)) return {
+				kind: "json",
+				type: "json",
+				feature: "type:slot"
+			};
+			return {
+				kind: "slot",
+				type: "slot"
+			};
+		case "table": return {
+			kind: "leaf",
+			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"
+			};
+			if (shopifyOnly(f.reference)) return {
+				kind: "leaf",
+				type: "text",
+				shopify: true
+			};
+			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, inItem = false, inSetting = false) {
+	const props = ctx.lane === "props";
+	const shape = shapeOf(f, lv, ctx, top, inTable ? "rows" : inItem ? "item" : inSetting ? "setting" : void 0);
+	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");
+	} else if (!props && modelKeyOf(f.name) !== f.name) {
+		node.key = modelKeyOf(f.name);
+		lose(ctx, `${at}/name`, "reserved name");
+	}
+	const nesting = shape.kind === "object" || shape.kind === "zones" || shape.kind === "types";
+	/** a list of items (objects, block models, item types, scalars or entries): ui.itemLabel names one item */
+	const listy = shape.kind === "zones" || shape.kind === "modular" || shape.kind === "types" || shape.kind === "itemType" || shape.kind === "refs";
+	const looseConfig = props || !STRICT_CONFIG.has(shape.type);
+	if (shape.kind === "json") lose(ctx, `${at}/type`, shape.feature);
+	const shopify = (shape.kind === "leaf" || shape.kind === "itemType") && shape.shopify === true;
+	if (shopify) {
+		if (f.readOnly !== true) lose(ctx, `${at}/readOnly`, "shopify reference");
+		node.readOnly = true;
+		node.lockReason = SHOPIFY_REF_LOCK;
+	}
+	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 (shape.kind === "types") node.config.mode = "types";
+	if (shape.kind === "slot" && props) node.config.multiple = true;
+	if (listy) {
+		const label = f.itemNoun !== void 0 ? capitalize(f.itemNoun) : props && 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;
+		}
+		if (shopify && (k === "reference" || k === "readOnly")) continue;
+		if (shopify && (k === "access" || k === "lockReason")) {
+			lose(ctx, p, "shopify reference");
+			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" || shape.kind === "slot")) 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 || props && shape.type === "code") 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 "archived":
+				if (f.archived) node.archived = true;
+				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" || shape.kind === "types" ? 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":
+				if (shape.kind === "slot") slotSettingsToProd(f.slotSettings, node, p, lv, ctx);
+				else 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" || shape.kind === "types") 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 "linkHref":
+				if (typeof f.linkHref === "string" && f.linkHref) node.config.linkHref = f.linkHref;
+				else lose(ctx, p, "unsupported key");
+				break;
+			case "svgOnly":
+				if (shape.type === "image" && f.svgOnly === true) node.config.media = "icon";
+				else if (f.svgOnly !== false) lose(ctx, p, "unsupported key");
+				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 (props && f.description === void 0) node.helpText = null;
+	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 (f.type === "rating" && node.type === "rating" && f.numeric?.step === void 0) {
+		const lo = typeof node.config.min === "number" ? node.config.min : 0;
+		const stops = ((typeof node.config.max === "number" ? node.config.max : 5) - lo) / V2_RATING_STEP;
+		if (Math.abs(stops - Math.round(stops)) < 1e-9 && Math.round(stops) <= 100) node.config.step = V2_RATING_STEP;
+	}
+	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 (!top) {
+			if (f.group !== void 0) {
+				if (ctx.keptTabs.has(f.group)) node.ui.tab = { id: f.group };
+				else lose(ctx, `${at}/group`, "group (nested)");
+			}
+		} else {
+			const t = ctx.propTabs.get(f);
+			if (t?.loss) lose(ctx, `${at}/group`, t.loss);
+			if (t?.tab) node.ui.tab = ctx.definedTabs.has(t.tab.id) ? { id: t.tab.id } : (ctx.definedTabs.add(t.tab.id), t.tab);
+		}
+		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, nest) => new Map(fields.map((c) => [c.name, writePlan(c, shapeOf(c, lv + 1, ctx, false, nest), 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 ?? [], ctx.lane === "props" ? "rows" : void 0)
+		};
+		case "types": return {
+			k: "types",
+			types: new Map(shape.items.map((i) => [i.name, kids(i.fields ?? [], "item")]))
+		};
+		case "slot": return ctx.lane === "fields" ? { k: "blocks" } : AS_IS;
+		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 (shape.shopify) return AS_IS;
+			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 ?? V2_RATING_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 and groups
+* read from its non-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, types, slots, blocks) {
+	const kids = (fields) => new Map(fields.map((c) => [c.name, readPlan(c, "", zoned, modular, types, slots, blocks)]));
+	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":
+			if (shopifyOnly(f.reference)) return AS_IS;
+			return { k: prodType === "form" ? "form" : "ref" };
+		case "object": return {
+			k: "object",
+			...zoned.has(f) ? { zoned: true } : {},
+			fields: kids(f.fields ?? [])
+		};
+		case "slot":
+			if (blocks?.has(f)) return { k: "blocks" };
+			return slots?.has(f) ? {
+				k: "slot",
+				multiple: slots.get(f)
+			} : AS_IS;
+		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 ?? [])]))
+			};
+			if (types?.has(f)) return {
+				k: "types",
+				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" && !shopifyOnly(item.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": {
+			const out = mapKeys(v, plan.fields, (p, x, k) => planToProd(p, x, lost, under(k)));
+			return plan.zoned && isObj(out) ? { nonRepeatable: out } : out;
+		}
+		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
+				};
+			});
+		case "blocks": return Array.isArray(v) ? v.map((c) => isObj(c) && typeof c._type === "string" ? {
+			...c,
+			_type: kebab(c._type)
+		} : c) : v;
+		case "slot": {
+			const kids = (type) => plan.child?.(type);
+			return slotChildrenToStored(plan.family ? childVariantsToTypes(v, plan.family) : v, plan.multiple !== false, (type, values, i) => {
+				const fields = kids(type);
+				return fields ? mapKeys(values, fields, (p, x, k) => planToProd(p, x, lost, `${under(i)}/${k}`)) : values;
+			}, (rel) => lost?.push(under(rel)));
+		}
+		case "types": return take(typedRowsToProd(v, (row, i) => {
+			const fields = plan.types.get(row._type);
+			return fields ? mapKeys(row, fields, (p, x, k) => planToProd(p, x, lost, `${under(i)}/${k}`)) : row;
+		}));
+		default: return v;
+	}
+}
+/** The keys the kit reads back from a stored image object (imageFromProd) and writes again (imageToProd). */
+var IMAGE_KIT_KEYS = /* @__PURE__ */ new Set([
+	"url",
+	"id",
+	"name",
+	"altText",
+	"focal"
+]);
+/**
+* Every key of a stored image the kit cannot hand back. A crop rect is read back as it is (imageFromProd), and an older
+* `{ src, alt }` value reads as its url and alt text, so neither is a loss (QA item 3); a malformed crop, or a key the
+* kit does not model, is.
+*/
+function imageStoredLoss(v, rel, loss) {
+	if (!isObj(v)) return;
+	const legacy = typeof v.url !== "string" && typeof v.src === "string";
+	for (const [k, x] of Object.entries(v)) {
+		if (IMAGE_KIT_KEYS.has(k) || x === void 0) continue;
+		if (legacy && k === "src") continue;
+		if (k === "alt" && typeof x === "string" && v.altText === void 0) continue;
+		if (k === "crop") {
+			if (x != null && !isCropRect(x)) loss(`${rel}/crop`, "A saved crop the kit can't read; 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": {
+			const env = plan.zoned && isObj(v) && "nonRepeatable" in v ? v : void 0;
+			if (env && loss) {
+				for (const k of Object.keys(env)) if (k !== "nonRepeatable" && env[k] !== void 0) loss(`${rel}/${k}`, `The group's saved "${k}" is not one of its fields; editing the group would drop it.`);
+			}
+			const at = env ? `${rel}/nonRepeatable` : rel;
+			return mapKeys(env ? isObj(env.nonRepeatable) ? env.nonRepeatable : {} : v, plan.fields, (p, x, k) => planFromProd(p, x, loss, `${at}/${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;
+		case "blocks": return Array.isArray(v) ? v.map((c) => isObj(c) && typeof c._type === "string" ? {
+			...c,
+			_type: camel(c._type)
+		} : c) : v;
+		case "slot": return slotChildrenFromStored(v, (type, values, i) => {
+			const fields = plan.child?.(type);
+			const read = fields ? mapKeys(values, fields, (p, x, k) => planFromProd(p, x, loss, `${rel}/${i}/${k}`)) : values;
+			const variant = plan.family?.(type)?.current;
+			return variant === void 0 ? read : {
+				...read,
+				_variant: variant
+			};
+		}, (i, reason) => loss?.(`${rel}/${i}`, reason));
+		case "types": return typedRowsFromProd(v, (row, i) => {
+			const fields = plan.types.get(row._type);
+			if (!fields) {
+				loss?.(`${rel}/${i}/_type`, `A stored row of item type "${row._type}", which this list no longer declares; editing the list would drop it.`);
+				return row;
+			}
+			return mapKeys(row, fields, (p, x, k) => planFromProd(p, x, loss, `${rel}/${i}/${k}`));
+		});
+		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 /* @__PURE__ */ 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 === "types" || shape.kind === "slot" || shape.kind === "itemType") {
+					const cap = shape.kind === "slot" ? SLOT_ITEMS_CAP : LIST_ITEMS_CAP;
+					if (props && top || shape.kind === "slot" ? isWhole(n, lo ? 0 : 1, 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 (shape.kind === "types") lose(ctx, p, "validation.unique");
+				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) cat(ctx, at, "segmented fallback");
+		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 === "types" || 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;
+		}
+		if (node.type === "table") return TABLE_PATH_KEYS.includes(segs[i]) && i === segs.length - 1 ? [...out, segs[i]].join(".") : void 0;
+		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 V2 dotted document preview path (`slides.0.heading`, `default.heading`) the backend keeps (componentPreviewRefusals
+* previewPathOfProps): its head a top-level prop, an index segment stepping into an item of a list, the rest a path
+* previewPathToProd stores unchanged (a renamed key, `image.alt` → `altText`, has no stored form here).
+*/
+function documentPreviewPathOk(path, keys, fields, ctx) {
+	const segs = path.split(".");
+	if (segs.length < 2 || !keys.has(segs[0])) return false;
+	const head = fields.find((f) => f.name === segs[0]);
+	if (!head) return false;
+	const polyOf = (f) => f.type === "array" && Array.isArray(f.of) && f.of.length > 1 && f.of.every((o) => o.type === "object") ? f.of : void 0;
+	let node = head;
+	const kept = [segs[0]];
+	let poly = false;
+	for (let i = 1; i < segs.length; i++) {
+		const seg = segs[i];
+		if (/^\d+$/.test(seg) && (node.type === "array" || node.type === "multiselect" || node.type === "tags")) continue;
+		const types = polyOf(node);
+		const kids = types ? types.flatMap((o) => o.fields ?? []) : previewKids(node);
+		if (!kids) {
+			kept.push(...segs.slice(i));
+			break;
+		}
+		const next = kids.find((c) => c.name === seg);
+		if (!next) return false;
+		if (types) poly = true;
+		kept.push(seg);
+		node = next;
+	}
+	if (poly) return true;
+	const clean = kept.join(".");
+	return previewPathToProd(clean, fields, ctx) === clean;
+}
+/**
+* A V2 schema's document-level preview → component.preview (BE componentPreviewSchema): `title` / `subtitle` / `media`
+* kept when they name a top-level prop key or a dotted path into one (else preview_key_unknown; a catalog note: the row
+* reads the first text),
+* `fallback` trimmed and at most COMPONENT_PREVIEW_FALLBACK_MAX, `icon` a dock icon.
+*/
+function componentPreviewToProd(pv, keys, fields, 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") {
+			if ((keys.has(v) || documentPreviewPathOk(v, keys, fields, ctx)) && v.length <= 64) out[k] = v;
+			else cat(ctx, `${at}/${k}`, "document preview path");
+		} else if (k === "fallback") {
+			const t = v.trim();
+			if (t && t === v && t.length <= 120) 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;
+	}
+	if (shape.kind === "types") return itemTypesToProd(shape.items, node, at, lv, ctx);
+	if (shape.kind === "slot") {
+		const of = f.of;
+		for (const k of Object.keys(of)) {
+			if (of[k] === void 0) continue;
+			if (k === "allow" && ctx.lane === "fields") {
+				node.config.blockSlugs = of.allow.map(kebab);
+				of.allow.forEach((n, i) => camel(kebab(n)) !== n && lose(ctx, `${at}/allow/${i}`, "type name"));
+			} else if (k === "allow") {
+				if (slotAllowOk(of.allow)) node.config.allow = [...of.allow];
+				else cat(ctx, `${at}/allow`, "slot allow");
+			} else if (k !== "type" || of.type !== "block") lose(ctx, `${at}/${k}`, "unsupported key");
+		}
+		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);
+	const settings = {};
+	const scalars = shape.kind === "itemType" && !shape.shopify && ctx.lane === "props";
+	for (const k of Object.keys(item)) {
+		const v = item[k];
+		if (v === void 0) continue;
+		const p = `${ip}/${k}`;
+		if (k === "name" || k === "title") continue;
+		if (k === "type") {
+			if (shape.kind === "itemType" && shape.shopify) continue;
+			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 if (k === "reference" && shape.kind === "itemType" && shape.shopify) continue;
+		else if (scalars && k === "description" && typeof v === "string" && v.trim() === v && v.length >= 1 && v.length <= 200) settings.helpText = v;
+		else if (scalars && k === "localized" && typeof v === "boolean") settings.localized = v;
+		else if (scalars && k === "validation") itemValidationToProd(item, shape.itemType, settings, p, ctx);
+		else lose(ctx, p, "item settings");
+	}
+	if (nonEmpty(settings)) node.config.item = settings;
+}
+/** A scalar list item's V2 validation → config.item: required, a text / rich text item's length, a text item's pattern. */
+function itemValidationToProd(item, itemType, out, at, ctx) {
+	const val = item.validation;
+	const lengthy = itemType === "text" || itemType === "richtext";
+	for (const k of Object.keys(val)) {
+		const v = val[k];
+		if (v === void 0) continue;
+		if (k === "required" && typeof v === "boolean") out.required = v;
+		else if ((k === "min" || k === "max") && lengthy && isWhole(v)) out[k === "min" ? "minLength" : "maxLength"] = v;
+		else if (k === "pattern" && itemType === "text" && typeof v === "string" && v.length <= 200 && compiles(v)) out.pattern = v;
+		else if (k === "patternMessage" && typeof v === "string" && v.trim() !== "" && v.length <= 200) out.patternMessage = v;
+		else lose(ctx, `${at}/${k}`, "item settings");
+	}
+	if (out.minLength !== void 0 && out.maxLength !== void 0 && out.minLength > out.maxLength) {
+		delete out.minLength;
+		delete out.maxLength;
+		lose(ctx, `${at}/min`, "item settings");
+	}
+	if (out.patternMessage !== void 0 && out.pattern === void 0) {
+		delete out.patternMessage;
+		lose(ctx, `${at}/patternMessage`, "item settings");
+	}
+}
+/** A slot's per-child settings → config.slotSettings: leaf sub-fields, at most SLOT_SETTINGS_MAX (slotSettingsHardening). */
+function slotSettingsToProd(settings, node, at, lv, ctx) {
+	const kept = settings.slice(0, SLOT_SETTINGS_MAX);
+	if (settings.length > SLOT_SETTINGS_MAX) settings.slice(SLOT_SETTINGS_MAX).forEach((_, i) => lose(ctx, `${at}/${SLOT_SETTINGS_MAX + i}`, "slotSettings"));
+	node.slotSettings = kept.map((c, i) => convertField(c, `${at}/${i}`, lv + 1, ctx, kept, false, false, false, true));
+}
+/**
+* A polymorphic list's item types → config.itemTypes `{ name, label, fields }`: the name is what a row's `_type` holds,
+* the title its label, its icon and row preview `icon` / `preview` (paths over its own fields). One prod cannot name is
+* not stored, which moves the ones after it up a place, so the whole list is named.
+*/
+function itemTypesToProd(items, node, at, lv, ctx) {
+	const names = /* @__PURE__ */ new Set();
+	node.itemTypes = [];
+	let dropped = false;
+	items.forEach((item, i) => {
+		const ip = `${at}/${i}`;
+		const fields = item.fields ?? [];
+		const why = !ITEM_TYPE_NAME.test(item.name) || !fields.length ? "item identity" : names.has(item.name) ? "duplicate name" : void 0;
+		if (why) {
+			lose(ctx, ip, why);
+			dropped = true;
+			return;
+		}
+		names.add(item.name);
+		const label = trunc(ctx, `${ip}/title`, item.title, ITEM_TYPE_LABEL_MAX, "item identity");
+		const children = fields.map((c, j) => convertField(c, `${ip}/fields/${j}`, lv + 1, ctx, fields, false, false, true));
+		const type = {
+			name: item.name,
+			label,
+			children
+		};
+		for (const k of Object.keys(item)) {
+			if (item[k] === void 0 || k === "name" || k === "title" || k === "type" || k === "fields") continue;
+			const p = `${ip}/${k}`;
+			if (k === "preview") {
+				const preview = previewToProd(item.preview, fields, p, ctx);
+				if (nonEmpty(preview)) type.preview = preview;
+			} else if (k === "icon") {
+				const dock = dockIconOf(item.icon);
+				if (dock) type.icon = dock;
+				else lose(ctx, p, "item icon");
+			} else if (k === "openMode") cat(ctx, p, "item openMode");
+			else lose(ctx, p, "item identity");
+		}
+		node.itemTypes.push(type);
+	});
+	if (dropped && node.itemTypes.length < items.length && node.itemTypes.length) lose(ctx, at, "item identity");
+}
+/**
+* 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");
+}
+/**
+* A reference's targets: entry models → contentModelId / polymorphic + allowedModelSlugs; page, form and collection →
+* config.targets and the filter → config.filter (backend refTargetKeys, both lanes). Read back, entry models come first,
+* then the targets.
+*/
+function referenceToConfig(ref, node, at, ctx) {
+	const to = ref.to ?? [];
+	const entries = to.filter(ENTRY_TARGET);
+	const targets = to.filter((t) => REF_TARGET_KINDS.includes(t));
+	const kept = entries.length + targets.length;
+	if (kept < to.length) lose(ctx, kept || !to.length ? `${at}/to` : at, "shopify reference");
+	else if (to.join() !== [...entries, ...targets].join()) lose(ctx, `${at}/to`, "reference order");
+	if (entries.length === 1) node.config.contentModelId = entries[0];
+	else if (entries.length > 1) Object.assign(node.config, {
+		polymorphic: true,
+		allowedModelSlugs: entries
+	});
+	if (targets.length) node.config.targets = targets;
+	if (ref.filter !== void 0) {
+		if (filterKept(ref.filter)) node.config.filter = ref.filter;
+		else 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 ?? (f.type === "rating" ? V2_RATING_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 = /* @__PURE__ */ 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;
+}
+/** V2 operator → prod showIf op (the legacy `equals` / `notEmpty` forms read as is / is one of / has a value). */
+var SHOW_IF_OP = {
+	is: "eq",
+	isNot: "neq",
+	in: "in",
+	notIn: "notIn",
+	empty: "empty",
+	notEmpty: "notEmpty",
+	gt: "gt",
+	lt: "lt"
+};
+var VALUELESS = /* @__PURE__ */ new Set([
+	"empty",
+	"notEmpty",
+	"isSet"
+]);
+function conditionToShowIf(h, at, siblings, ctx, variantOk) {
+	const rules = [];
+	for (const [i, r] of [h, ...h.also ?? []].entries()) {
+		const rule = conditionRule(r, i === 0, siblings, variantOk);
+		if (!rule) return void lose(ctx, at, "condition");
+		rules.push(rule);
+	}
+	if (h.match !== void 0 && h.match !== "all" && h.match !== "any") return void lose(ctx, at, "condition");
+	return {
+		match: h.match ?? "all",
+		rules
+	};
+}
+/** One V2 rule as a prod rule, or null when prod cannot hold it (a scope, a non-sibling, a value showIf cannot test). */
+function conditionRule(r, head, siblings, variantOk) {
+	const variant = variantOk && r.field === "_variant";
+	if (!r.field || r.scope !== void 0 || !variant && !siblings.some((s) => s.name === r.field)) return null;
+	const allowed = head ? [
+		"field",
+		"equals",
+		"notEmpty",
+		"op",
+		"value",
+		"also",
+		"match"
+	] : [
+		"field",
+		"equals",
+		"notEmpty",
+		"op",
+		"value"
+	];
+	if (Object.keys(r).some((k) => !allowed.includes(k) && r[k] !== void 0)) return null;
+	if ([
+		r.op !== void 0,
+		r.equals !== void 0,
+		r.notEmpty !== void 0
+	].filter(Boolean).length !== 1) return null;
+	if (r.notEmpty !== void 0) return r.notEmpty === true ? {
+		field: r.field,
+		op: "notEmpty"
+	} : null;
+	const target = r.op !== void 0 ? r.value : r.equals;
+	const op = r.op !== void 0 ? SHOW_IF_OP[r.op] : Array.isArray(target) ? "in" : "eq";
+	if (!op) return null;
+	if (VALUELESS.has(op)) return r.value === void 0 ? {
+		field: r.field,
+		op
+	} : null;
+	const sibType = variant ? void 0 : siblings.find((s) => s.name === r.field)?.type;
+	if (op === "gt" || op === "lt") return typeof target === "number" && Number.isFinite(target) ? {
+		field: r.field,
+		op,
+		value: String(target)
+	} : null;
+	const list = Array.isArray(target) ? target : [target];
+	const strs = [];
+	for (const v of list) {
+		if (![
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof v)) return null;
+		const s = String(v);
+		if (coerceRuleValue(sibType, s) !== v) return null;
+		strs.push(s);
+	}
+	if (op === "in" || op === "notIn") return {
+		field: r.field,
+		op,
+		value: strs
+	};
+	return Array.isArray(target) ? strs.length ? {
+		field: r.field,
+		op: op === "eq" ? "in" : "notIn",
+		value: strs
+	} : null : {
+		field: r.field,
+		op,
+		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",
+		"archived"
+	]) 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.slotSettings) config.slotSettings = n.slotSettings.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 (n.itemTypes) config.itemTypes = emitItemTypes(n.itemTypes);
+	if (n.slotSettings) config.slotSettings = n.slotSettings.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);
+	const config = { ...n.config };
+	if (n.itemTypes) config.itemTypes = emitItemTypes(n.itemTypes);
+	if (n.slotSettings) config.slotSettings = n.slotSettings.map(emitSubField);
+	if (nonEmpty(config)) out.config = config;
+	const ui = nonEmpty(n.ui);
+	if (ui) out.ui = ui;
+	return out;
+}
+/** A polymorphic list's item types as the backend stores them: `{ name, label, fields }` (typesTableHardening). */
+var emitItemTypes = (types) => types.map((t) => ({
+	name: t.name,
+	label: t.label,
+	fields: t.children.map(emitSubField),
+	...t.icon ? { icon: t.icon } : {},
+	...t.preview ? { preview: t.preview } : {}
+}));
+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,
+		propTabs: /* @__PURE__ */ new Map(),
+		definedTabs: /* @__PURE__ */ new Set(),
+		keptTabs: /* @__PURE__ */ new Set(),
+		declaredTabs: [],
+		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":
+				if (!props || !dockIconOf(v2.icon)) cat(ctx, p, "block icon");
+				break;
+			case "preview":
+				if (!props) 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) {
+		propTabsFor(v2, ctx);
+		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;
+		const icon = v2.icon === void 0 ? void 0 : dockIconOf(v2.icon);
+		if (icon) component.icon = icon;
+		if (v2.preview !== void 0) {
+			const preview = componentPreviewToProd(v2.preview, new Set(component.props.map((x) => x.key)), v2.fields, "/preview", ctx);
+			if (Object.keys(preview).length) component.preview = preview;
+		}
+		if (ctx.declaredTabs.length) component.tabs = ctx.declaredTabs.map((t) => ({ ...t }));
+		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, 40);
+		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 > 40) lose(ctx, `${p}/title`, "group name>40");
+		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: V2 groups → each top-level prop's `ui.tab`, defined on the first prop in it (label, icon, and `order` when
+* the V2 order differs from where each tab is first used). A field with no group sits in the V2 default group; a group
+* not stored puts its fields in the default tab; a fieldset's top-level members share the tab most of them sit in
+* (prop_group_split_tabs). No groups → no tab anywhere, so a component without tabs stores as before.
+*/
+function propTabsFor(v2, ctx) {
+	const groups = v2.groups ?? [];
+	const kept = [];
+	const dropped = /* @__PURE__ */ new Map();
+	const labels = /* @__PURE__ */ new Set();
+	groups.forEach((g, i) => {
+		const p = `/groups/${i}`;
+		const drop = (why) => {
+			if (!kept.some((k) => k.g.name === g.name) && !dropped.has(g.name)) dropped.set(g.name, why);
+			lose(ctx, p, why);
+		};
+		const label = g.title.slice(0, 40).trim();
+		const folded = label.toLowerCase();
+		if (kept.some((k) => k.g.name === g.name) || labels.has(folded)) return drop("group name collision");
+		if (kept.length >= 8 || g.name.length < 1 || g.name.length > 40) return drop("prop tab limit");
+		if (!label) return drop("group title");
+		labels.add(folded);
+		const tab = {
+			id: g.name,
+			label
+		};
+		if (label !== g.title.trim()) lose(ctx, `${p}/title`, "group name>40");
+		else if (label !== g.title) lose(ctx, `${p}/title`, "group title");
+		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");
+		kept.push({
+			g,
+			i,
+			tab
+		});
+	});
+	const isKept = (name) => name !== void 0 && kept.some((k) => k.g.name === name);
+	const v2Default = (groups.find((g) => g.default) ?? groups[0])?.name;
+	const fallback = isKept(v2Default) ? v2Default : kept[0]?.g.name;
+	const place = /* @__PURE__ */ new Map();
+	for (const f of v2.fields) {
+		const want = f.group ?? v2Default;
+		if (isKept(want)) place.set(f, { tab: want });
+		else if (f.group !== void 0 || want !== void 0) place.set(f, {
+			tab: fallback,
+			loss: dropped.get(want) ?? "unsupported key"
+		});
+	}
+	if (!kept.length) {
+		for (const [f, t] of place) if (f.group !== void 0) ctx.propTabs.set(f, { loss: t.loss });
+		return;
+	}
+	const tally = /* @__PURE__ */ new Map();
+	for (const f of v2.fields) {
+		if (f.fieldset === void 0) continue;
+		const t = tally.get(f.fieldset) ?? /* @__PURE__ */ new Map();
+		t.set(place.get(f)?.tab, (t.get(place.get(f)?.tab) ?? 0) + 1);
+		tally.set(f.fieldset, t);
+	}
+	for (const f of v2.fields) {
+		const counts = f.fieldset !== void 0 ? tally.get(f.fieldset) : void 0;
+		if (!counts) continue;
+		const best = [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+		const cur = place.get(f);
+		if (cur?.tab !== best) place.set(f, {
+			tab: best,
+			loss: cur?.loss ?? "fieldset spans groups"
+		});
+	}
+	const firstUse = [];
+	for (const f of v2.fields) {
+		const t = place.get(f)?.tab;
+		if (t !== void 0 && !firstUse.includes(t)) firstUse.push(t);
+	}
+	const used = kept.filter((k) => firstUse.includes(k.g.name));
+	const unused = kept.filter((k) => !firstUse.includes(k.g.name));
+	for (const k of kept) ctx.keptTabs.add(k.g.name);
+	const firstGap = groups.findIndex((g) => !kept.some((k) => k.g === g));
+	if (firstGap >= 0 && kept.some((k) => k.i > firstGap)) {
+		const g = groups[firstGap];
+		lose(ctx, "/groups", dropped.get(g.name) ?? "unsupported key");
+	}
+	const ordered = unused.length > 0 || used.some((k, i) => k.g.name !== firstUse[i]);
+	kept.forEach((k, i) => {
+		if (ordered) k.tab.order = Math.min(99, i);
+	});
+	ctx.declaredTabs = unused.map((k) => k.tab);
+	for (const [f, t] of place) {
+		const k = used.find((u) => u.g.name === t.tab);
+		if (k) ctx.propTabs.set(f, {
+			tab: k.tab,
+			loss: t.loss
+		});
+		else if (t.loss) ctx.propTabs.set(f, { loss: t.loss });
+	}
+}
+/**
+* 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 ?? [];
+	const named = new Set(sets.map((s) => s.name));
+	const firstSeen = [];
+	const undeclared = [];
+	const visit = (fields, lv) => {
+		for (const f of fields) {
+			if (f.fieldset !== void 0 && !firstSeen.includes(f.fieldset)) {
+				firstSeen.push(f.fieldset);
+				if (!named.has(f.fieldset)) undeclared.push(f.fieldset);
+			}
+			if (lv >= 10) continue;
+			const kids = previewKids(f);
+			if (kids) visit(kids, lv + 1);
+		}
+	};
+	visit(v2.fields, 1);
+	const derived = undeclared.map((name) => ({
+		name,
+		title: name
+	}));
+	const declaredUsed = sets.filter((s) => firstSeen.includes(s.name)).length;
+	derived.forEach((s, j) => {
+		ctx.propSets.set(s.name, s);
+		ctx.propOrder.set(s.name, sets.length + j);
+		cat(ctx, `/fieldsets/${declaredUsed + j}`, "fieldset (derived)");
+	});
+	if (!sets.length && !derived.length) return;
+	ctx.groupOrder = [...sets, ...derived].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 (f.type === "array" && !cfg.zones && Array.isArray(cfg.fields)) {
+		n.fields = [...n.fields ?? [], ...cfg.fields.map(readField)];
+		delete cfg.fields;
+	}
+	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;
+}
+/**
+* Slot children with each `_variant` written as the family member that places it (`_type`): the variant the child's
+* component already is drops, another member swaps in. A variant no member places stays, and the write names it lost.
+*/
+function childVariantsToTypes(v, family) {
+	if (!Array.isArray(v)) return v;
+	return v.map((c) => {
+		if (!isObj(c) || typeof c._variant !== "string") return c;
+		const own = family(typeof c._type === "string" ? c._type : "");
+		const { _variant: _gone, ...rest } = c;
+		if (own?.current === c._variant) return rest;
+		const member = own?.member(c._variant);
+		if (!member) return c;
+		return {
+			...rest,
+			_type: member
+		};
+	});
+}
+/** 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",
+	"array"
+].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 conds = [];
+	for (const r of s.rules) {
+		const c = showIfRuleToCondition(r, siblings);
+		if (!c) return void ctx.onLoss(at, "condition", `V2 conditions have no "${r.op}" with this value; the field always shows.`);
+		conds.push(c);
+	}
+	if (!conds.length) return void 0;
+	const [head, ...also] = conds;
+	return {
+		...head,
+		...also.length ? { also } : {},
+		...s.match === "any" && conds.length > 1 ? { match: "any" } : {}
+	};
+}
+/** One prod rule as a V2 rule: eq / in / isSet keep V2's legacy forms, the rest name their `op`. */
+function showIfRuleToCondition(r, siblings) {
+	const sib = siblings.find((x) => x.key === r.field);
+	const t = sib?.type === "number" ? "number" : sib?.type;
+	const read = (v) => coerceRuleValue(t, v);
+	const list = (Array.isArray(r.value) ? r.value : [r.value ?? ""]).map(read);
+	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: list
+		};
+		case "isSet":
+		case "notEmpty": return {
+			field: r.field,
+			notEmpty: true
+		};
+		case "empty": return {
+			field: r.field,
+			op: "empty"
+		};
+		case "neq": return {
+			field: r.field,
+			op: "isNot",
+			value: Array.isArray(r.value) ? list : read(r.value ?? "")
+		};
+		case "notIn": return {
+			field: r.field,
+			op: "notIn",
+			value: list
+		};
+		case "gt":
+		case "lt": {
+			const n = Number(r.value);
+			return typeof r.value === "string" && r.value.trim() !== "" && Number.isFinite(n) ? {
+				field: r.field,
+				op: r.op,
+				value: n
+			} : void 0;
+		}
+		default: return;
+	}
+}
+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 holds one TableValue: the V2 `table` field, not a list of rows. A prop says so (config.mode "data");
+	*  a field's table is always one (BE tableFieldSchema: `mode` is optional there and can only be "data") */
+	const dataTable = isDataTableProp(n) || lane === "fields" && n.type === "table";
+	/** a slot prop: component instances, read as the V2 slot (its children `{ _key, _type, _settings?, ...props }`) */
+	const slotProp = lane === "props" && n.type === "slot";
+	/** a model slot field: inline children of the kind:'block' models config.blockSlugs names */
+	const blockSlot = lane === "fields" && n.type === "slot";
+	const type = dataTable ? "table" : slotProp || blockSlot ? "slot" : 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 (typeof n.helpText === "string") 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.archived === true) f.archived = 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;
+	const shopify = n.readOnly === true && n.lockReason === "A Shopify product id. No Shopify integration backs a reference in BetterCMS yet, so the id is kept as it is." && (n.type === "text" || n.type === "array" && n.config.itemType === "text");
+	if (shopify) {
+		delete f.lockReason;
+		if (n.type === "text") {
+			f.type = "reference";
+			f.reference = { to: ["shopify"] };
+		}
+	}
+	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;
+	if (lane === "props" && n.ui.tab) f.group = n.ui.tab.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 = /* @__PURE__ */ new Set([
+		"placeholder",
+		"zones",
+		"options",
+		"fields"
+	]);
+	const usedUi = /* @__PURE__ */ 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 (lane === "props") useUi("tab");
+	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];
+		if (n.type === "rating") {
+			if (numeric.step === V2_RATING_STEP) delete numeric.step;
+			else if (numeric.step === void 0) numeric.step = 1;
+		}
+		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 (n.type === "image") {
+		use("media");
+		if (cfg.media === "icon") f.svgOnly = true;
+	}
+	if (typeof cfg.linkHref === "string" && cfg.linkHref) f.linkHref = cfg.linkHref;
+	use("linkHref");
+	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", "targets", "filter");
+	if (n.type === "reference") {
+		const ref = referenceFromConfig(cfg);
+		if (ref) f.reference = ref;
+	}
+	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 fields = nr.map((c, i) => readToV2(c, `${at}/config/zones/nonRepeatable/${i}`, nr, ctx, false, lane));
+		if (n.zones.repeatable) {
+			const kids = [{
+				name: "nonRepeatable",
+				title: n.label,
+				type: "object",
+				fields
+			}, listOf(n, n.zones.repeatable.fields, "repeatable", `${at}/config/zones/repeatable`, ctx, lane)];
+			ctx.onLoss(`${at}/config/zones`, "zone envelope", "A zone pair reads as an object with nonRepeatable and repeatable children, matching its stored {nonRepeatable, repeatable} value.");
+			Object.assign(f, {
+				type: "object",
+				fields: kids
+			});
+		} else {
+			Object.assign(f, {
+				type: "object",
+				fields
+			});
+			ctx.zoned.add(f);
+		}
+	} else if (slotProp) {
+		const ids = Array.isArray(cfg.componentIds) ? cfg.componentIds.filter((x) => typeof x === "string") : [];
+		const names = Array.isArray(cfg.allow) ? cfg.allow.filter((x) => typeof x === "string") : [];
+		f.of = ids.length ? {
+			type: "block",
+			allow: ids
+		} : names.length ? {
+			type: "block",
+			allow: names
+		} : { type: "block" };
+		ctx.slots.set(f, cfg.multiple === true);
+		const settings = Array.isArray(cfg.slotSettings) ? cfg.slotSettings.map(readProp) : [];
+		if (settings.length) f.slotSettings = settings.map((c, k) => readToV2(c, `${at}/config/slotSettings/${k}`, settings, ctx, false, lane));
+		if (cfg.multiple !== true) {
+			val.max = 1;
+			loss("config/multiple", "slot single", "A single slot holds one component instance; V2 reads it as a slot of at most one block.");
+		} else {
+			if (typeof cfg.minItems === "number") val.min = cfg.minItems;
+			if (typeof cfg.maxItems === "number") val.max = cfg.maxItems;
+		}
+		use("multiple", "componentIds", "allow", "minItems", "maxItems", "slotSettings");
+	} else if (blockSlot) {
+		const slugs = Array.isArray(cfg.blockSlugs) ? cfg.blockSlugs.filter((x) => typeof x === "string") : [];
+		f.of = slugs.length ? {
+			type: "block",
+			allow: slugs.map(camel)
+		} : { type: "block" };
+		ctx.blocks.add(f);
+		const settings = Array.isArray(cfg.slotSettings) ? cfg.slotSettings.map(readField) : [];
+		if (settings.length) f.slotSettings = settings.map((c, k) => readToV2(c, `${at}/config/slotSettings/${k}`, settings, ctx, false, lane));
+		if (typeof cfg.minItems === "number") val.min = cfg.minItems;
+		if (typeof cfg.maxItems === "number") val.max = cfg.maxItems;
+		use("blockSlugs", "minItems", "maxItems", "slotSettings");
+	} else if (lane === "props" && n.type === "table" && cfg.mode === "types") {
+		f.of = (Array.isArray(cfg.itemTypes) ? cfg.itemTypes : []).map((t, j) => {
+			const kids = (t.fields ?? []).map(readProp);
+			const item = {
+				name: t.name,
+				title: t.label ?? t.name,
+				type: "object",
+				fields: kids.map((c, k) => readToV2(c, `${at}/config/itemTypes/${j}/fields/${k}`, kids, ctx, false, lane))
+			};
+			if (t.icon) item.icon = tablerIconOf(t.icon);
+			if (t.preview) item.preview = previewFromProd(t.preview, kids);
+			return item;
+		});
+		ctx.types.add(f);
+		if (n.ui.itemLabel !== void 0) 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 item types.`);
+		if (typeof cfg.minItems === "number") val.min = cfg.minItems;
+		if (typeof cfg.maxItems === "number") val.max = cfg.maxItems;
+		use("mode", "itemTypes", "minItems", "maxItems");
+		useUi("itemLabel", "icon", "layout");
+	} 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.zones && !cfg.itemType && n.fields?.length) || 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 = [shopify ? {
+			...itemOf(n),
+			type: "reference",
+			reference: { to: ["shopify"] }
+		} : {
+			...itemOf(n),
+			type: cfg.itemType === "text" ? "string" : cfg.itemType,
+			...itemSettingsFromProd(cfg.item)
+		}];
+		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", "item");
+		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 ref = referenceFromConfig(cfg);
+		f.of = [{
+			...itemOf(n),
+			type: "reference",
+			...ref ? { reference: ref } : {}
+		}];
+		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)) continue;
+		if (isHostConfigKey(n.type, k) || isHostConfigKey(type, k)) loss(`config/${k}`, "host config", CATALOG["host config"]);
+		else 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, ctx.types, ctx.slots, ctx.blocks);
+		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;
+}
+/** config.item → the V2 item field's description, localized flag and validation (in V2's key order). */
+function itemSettingsFromProd(item) {
+	if (!isObj(item)) return {};
+	const s = item;
+	const out = {};
+	const val = {};
+	if (s.required !== void 0) val.required = s.required;
+	if (s.minLength !== void 0) val.min = s.minLength;
+	if (s.maxLength !== void 0) val.max = s.maxLength;
+	if (s.pattern !== void 0) val.pattern = s.pattern;
+	if (s.patternMessage !== void 0) val.patternMessage = s.patternMessage;
+	if (Object.keys(val).length) out.validation = val;
+	if (s.localized !== void 0) out.localized = s.localized;
+	if (s.helpText !== void 0) out.description = s.helpText;
+	return out;
+}
+/** A reference config → the V2 `reference`: entry models first, then config.targets; config.filter as written. */
+function referenceFromConfig(cfg) {
+	const entries = cfg.polymorphic ? cfg.allowedModelSlugs ?? [] : cfg.contentModelId ? [cfg.contentModelId] : [];
+	const targets = Array.isArray(cfg.targets) ? cfg.targets.filter((t) => typeof t === "string") : [];
+	const to = [...entries, ...targets];
+	if (!to.length && typeof cfg.filter !== "string") return void 0;
+	return {
+		to,
+		...typeof cfg.filter === "string" ? { filter: cfg.filter } : {}
+	};
+}
+/** 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(),
+		types: /* @__PURE__ */ new WeakSet(),
+		slots: /* @__PURE__ */ new WeakMap(),
+		blocks: /* @__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(),
+		types: /* @__PURE__ */ new WeakSet(),
+		slots: /* @__PURE__ */ new WeakMap(),
+		blocks: /* @__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 groups = [];
+	const tabOrder = /* @__PURE__ */ new Map();
+	for (const t of [...nodes.map((n) => n.ui.tab), ...component.tabs ?? []]) {
+		if (!t || groups.some((g) => g.name === t.id)) continue;
+		const g = {
+			name: t.id,
+			title: t.label ?? t.id
+		};
+		if (t.icon) g.icon = tablerIconOf(t.icon);
+		if (typeof t.order === "number") tabOrder.set(t.id, t.order);
+		groups.push(g);
+	}
+	if (tabOrder.size) {
+		const at = new Map(groups.map((g, i) => [g.name, i]));
+		groups.sort((a, b) => (tabOrder.get(a.name) ?? at.get(a.name)) - (tabOrder.get(b.name) ?? at.get(b.name)));
+	}
+	if (groups.length) groups[0].default = true;
+	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 (component.icon) out.icon = tablerIconOf(component.icon);
+	if (component.preview) out.preview = previewFromProd(component.preview, nodes);
+	if (fieldsets.length) out.fieldsets = fieldsets;
+	if (groups.length) out.groups = groups;
+	return out;
+}
+//#endregion
+export { CATEGORY_TO_PROD, SHOPIFY_REF_LOCK, fromTypeSchema, leafValuePlan, planFromProd, planToProd, propsToTypeSchema, schemaSlugOf, toTypeSchema };
+
+//# sourceMappingURL=schema.js.map