@yahoo/uds-create-config 2.45.0 → 3.0.1

package/dist/native/validation.js

@@ -1,885 +0,0 @@
-import { isAssetRef, isTokenRef } from "../refs.js";
-import { isMixExpr } from "../colorExpressions.js";
-import { EXACT_SEMVER_RE, UUID_RE } from "../linked-system-pins.js";
-import { createModeBackedModifierLookup, modifierTreeToOverrideRows, resolveOverrideRow } from "../token-override-rows.js";
-import { isOperatingSystemValue } from "./values.js";
-import { validRange } from "semver";
-//#region src/native/validation.ts
-const TOP_LEVEL_KEYS = new Set([
-	"schemaVersion",
-	"platform",
-	"builtAt",
-	"namespace",
-	"styleEngine",
-	"buildOptions",
-	"dependencyPolicy",
-	"defaultModes",
-	"modes",
-	"tokenGroups",
-	"assetGroups",
-	"components",
-	"componentGroups",
-	"linkedSystems"
-]);
-const LINKED_SYSTEM_PIN_KEYS = new Set(["name", "version"]);
-const BUILD_OPTIONS_KEYS = new Set(["componentsDir"]);
-const DEPENDENCY_POLICY_KEYS = new Set(["providedBy", "version"]);
-const COMPONENT_KEYS = new Set([
-	"id",
-	"layers",
-	"props",
-	"defaultProps",
-	"styles",
-	"label",
-	"description"
-]);
-const COMPONENT_CONFIG_KEYS = new Set([
-	"base",
-	"variants",
-	"booleans",
-	"runtimeStates",
-	"values",
-	"description"
-]);
-const LAYER_KEYS = new Set(["kind", "styleProp"]);
-const COMPONENT_GROUP_KEYS = new Set([
-	"components",
-	"label",
-	"description"
-]);
-const GROUP_KEYS = new Set([
-	"tokens",
-	"label",
-	"description"
-]);
-const ASSET_GROUP_KEYS = new Set([
-	"assetKind",
-	"members",
-	"label",
-	"description"
-]);
-const ASSET_MEMBER_KEYS = new Set(["fontFamily"]);
-const MODE_OPTION_KEYS = new Set([
-	"modifier",
-	"label",
-	"description",
-	"appearance",
-	"minWidth",
-	"css",
-	"media"
-]);
-const APPEARANCES = new Set(["light", "dark"]);
-const OS_KEYS = new Set([
-	"__kind",
-	"default",
-	"ios",
-	"android"
-]);
-const TOKEN_REF_KEYS = new Set(["__kind", "ref"]);
-const MIX_KEYS = new Set([
-	"__kind",
-	"from",
-	"to",
-	"amount",
-	"colorSpace"
-]);
-const COLOR_SPACES = new Set([
-	"srgb",
-	"srgb-linear",
-	"oklab",
-	"oklch",
-	"lab",
-	"lch",
-	"hsl",
-	"hwb"
-]);
-function validateSerializedNativeConfig(input, expectedSchemaVersion = 4) {
-	const diagnostics = [];
-	const configDefinition = { kind: "config" };
-	if (!isRecord(input)) {
-		push(diagnostics, "INVALID_SCHEMA", [], configDefinition, "Native config must be a plain object.");
-		return diagnostics;
-	}
-	reportUnknownKeys(input, TOP_LEVEL_KEYS, [], configDefinition, diagnostics);
-	if (input.schemaVersion !== expectedSchemaVersion) push(diagnostics, typeof input.schemaVersion === "number" ? "UNSUPPORTED_SCHEMA_VERSION" : "INVALID_SCHEMA", ["schemaVersion"], configDefinition, `Native config schema version must be ${expectedSchemaVersion}; received ${String(input.schemaVersion)}.`);
-	if (input.platform !== "native") push(diagnostics, "PLATFORM_MISMATCH", ["platform"], configDefinition, "Native config must declare platform: \"native\".");
-	if (input.builtAt !== void 0 && typeof input.builtAt !== "string") push(diagnostics, "INVALID_SCHEMA", ["builtAt"], configDefinition, "builtAt must be a string when present.");
-	validateNamespace(input.namespace, diagnostics);
-	validateStyleEngine(input.styleEngine, diagnostics);
-	validateBuildOptions(input.buildOptions, diagnostics);
-	validateDependencyPolicy(input.dependencyPolicy, diagnostics);
-	validateModes(input.modes, diagnostics);
-	validateDefaultModes(input.defaultModes, input.modes, diagnostics);
-	validateAssetGroups(input.assetGroups, diagnostics);
-	validateTokenGroups(input.tokenGroups, diagnostics);
-	validateComponents(input.components, diagnostics);
-	validateComponentGroups(input.componentGroups, input.components, diagnostics);
-	validateLinkedSystems(input.linkedSystems, diagnostics);
-	validateReferences(input, diagnostics);
-	validateModifierOwnership(input, diagnostics);
-	return dedupe(diagnostics);
-}
-function validateDependencyPolicy(value, diagnostics) {
-	if (value === void 0) return;
-	const definition = { kind: "config" };
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_DEPENDENCY_POLICY", ["dependencyPolicy"], definition, "dependencyPolicy must be a record keyed by npm package name.");
-		return;
-	}
-	for (const [name, policy] of Object.entries(value)) {
-		const path = ["dependencyPolicy", name];
-		if (!isValidPackageName(name)) push(diagnostics, "INVALID_DEPENDENCY_POLICY", path, definition, `"${name}" is not a valid npm package name.`);
-		if (!isRecord(policy)) {
-			push(diagnostics, "INVALID_DEPENDENCY_POLICY", path, definition, "Dependency policy entries must be plain objects.");
-			continue;
-		}
-		reportUnknownKeys(policy, DEPENDENCY_POLICY_KEYS, path, definition, diagnostics);
-		if (policy.providedBy !== "consumer" && policy.providedBy !== "registry") push(diagnostics, "INVALID_DEPENDENCY_POLICY", [...path, "providedBy"], definition, "providedBy must be either \"consumer\" or \"registry\".");
-		if (typeof policy.version !== "string" || validRange(policy.version) === null) push(diagnostics, "INVALID_DEPENDENCY_POLICY", [...path, "version"], definition, "version must be a valid semver range.");
-	}
-}
-function isValidPackageName(name) {
-	if (name.length === 0 || name.length > 214 || name !== name.toLowerCase()) return false;
-	return /^(?:@[a-z0-9~][a-z0-9._~-]*\/)?[a-z0-9~][a-z0-9._~-]*$/.test(name);
-}
-function validateLinkedSystems(value, diagnostics) {
-	if (value === void 0) return;
-	const definition = { kind: "config" };
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["linkedSystems"], definition, "linkedSystems must be a record keyed by source-system UUID.");
-		return;
-	}
-	for (const [systemId, pin] of Object.entries(value)) {
-		const path = ["linkedSystems", systemId];
-		if (!UUID_RE.test(systemId)) push(diagnostics, "INVALID_SCHEMA", path, definition, "Linked-system pins are keyed by the source system UUID.");
-		if (!isRecord(pin)) {
-			push(diagnostics, "INVALID_SCHEMA", path, definition, "A linked-system pin must be an object with name and version.");
-			continue;
-		}
-		reportUnknownKeys(pin, LINKED_SYSTEM_PIN_KEYS, path, definition, diagnostics);
-		if (typeof pin.name !== "string" || pin.name.trim().length === 0) push(diagnostics, "INVALID_SCHEMA", [...path, "name"], definition, "A linked-system pin requires a non-empty display name.");
-		if (typeof pin.version !== "string" || !EXACT_SEMVER_RE.test(pin.version)) push(diagnostics, "INVALID_SCHEMA", [...path, "version"], definition, "A linked-system pin requires an exact semver version (no ranges).");
-	}
-}
-function validateBuildOptions(value, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["buildOptions"], { kind: "config" }, "Native buildOptions must be an object.");
-		return;
-	}
-	reportUnknownKeys(value, BUILD_OPTIONS_KEYS, ["buildOptions"], { kind: "config" }, diagnostics);
-	if (value.componentsDir !== void 0 && (typeof value.componentsDir !== "string" || value.componentsDir.length === 0)) push(diagnostics, "INVALID_SCHEMA", ["buildOptions", "componentsDir"], { kind: "config" }, "Native componentsDir must be a non-empty path string.");
-}
-function validateComponents(value, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["components"], { kind: "config" }, "Native components must be a record.");
-		return;
-	}
-	const ids = /* @__PURE__ */ new Map();
-	for (const [componentName, component] of Object.entries(value)) {
-		const path = ["components", componentName];
-		const definition = {
-			kind: "component",
-			name: componentName
-		};
-		if (!isRecord(component)) {
-			push(diagnostics, "INVALID_SCHEMA", path, definition, `Native component "${componentName}" must be an object.`);
-			continue;
-		}
-		reportUnknownKeys(component, COMPONENT_KEYS, path, definition, diagnostics);
-		if (typeof component.id !== "string" || component.id.length === 0) push(diagnostics, "INVALID_SCHEMA", [...path, "id"], definition, `Native component "${componentName}" must declare a stable id.`);
-		else {
-			const owner = ids.get(component.id);
-			if (owner !== void 0) push(diagnostics, "INVALID_SCHEMA", [...path, "id"], definition, `Native component id "${component.id}" is already registered as "${owner}".`);
-			else ids.set(component.id, componentName);
-		}
-		const layerNames = validateComponentLayers(component.layers, [...path, "layers"], definition, diagnostics);
-		validateComponentConfig(component.styles, [...path, "styles"], definition, layerNames, diagnostics);
-		validateComponentProps(component.props, path, definition, diagnostics);
-		validateComponentStyleProps(component, path, definition, diagnostics);
-	}
-}
-function validateComponentStyleProps(component, path, definition, diagnostics) {
-	const props = isRecord(component.props) ? component.props : {};
-	const styles = isRecord(component.styles) ? component.styles : {};
-	for (const [groupName, expectedKind] of [["variants", "variant"], ["booleans", "boolean"]]) {
-		const groups = styles[groupName];
-		if (!isRecord(groups)) continue;
-		for (const [propName, options] of Object.entries(groups)) {
-			const marker = props[propName];
-			if (!isRecord(marker) || marker.__kind !== expectedKind) {
-				push(diagnostics, "INVALID_REFERENCE", [
-					...path,
-					"styles",
-					groupName,
-					propName
-				], definition, `Native ${groupName} styles must target a ${expectedKind} component prop.`);
-				continue;
-			}
-			if (!isRecord(options)) continue;
-			const allowedOptions = expectedKind === "variant" && Array.isArray(marker.values) ? new Set(marker.values.map(String)) : new Set(["true", "false"]);
-			for (const optionName of Object.keys(options)) if (!allowedOptions.has(optionName)) push(diagnostics, "INVALID_REFERENCE", [
-				...path,
-				"styles",
-				groupName,
-				propName,
-				optionName
-			], definition, expectedKind === "variant" ? `Native variant style option "${optionName}" is not declared by prop "${propName}".` : `Native boolean style option "${optionName}" must be true or false.`);
-		}
-	}
-}
-function validateComponentProps(value, componentPath, definition, diagnostics) {
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", [...componentPath, "props"], definition, "Native component props must be a record.");
-		return;
-	}
-	for (const [propName, marker] of Object.entries(value)) {
-		if (!isRecord(marker) || ![
-			"slot",
-			"boolean",
-			"string",
-			"number",
-			"variant"
-		].includes(String(marker.__kind))) {
-			push(diagnostics, "INVALID_SCHEMA", [
-				...componentPath,
-				"props",
-				propName
-			], definition, `Unknown native component prop marker "${String(isRecord(marker) ? marker.__kind : marker)}".`);
-			continue;
-		}
-		if (marker.__kind === "variant") {
-			if (!Array.isArray(marker.values) || marker.values.length === 0 || marker.values.some((option) => typeof option !== "string" && typeof option !== "number" || typeof option === "number" && !Number.isFinite(option))) push(diagnostics, "INVALID_SCHEMA", [
-				...componentPath,
-				"props",
-				propName,
-				"values"
-			], definition, "Native variant props require at least one finite number or string option.");
-			else if (new Set(marker.values.map(String)).size !== marker.values.length) push(diagnostics, "INVALID_SCHEMA", [
-				...componentPath,
-				"props",
-				propName,
-				"values"
-			], definition, "Native variant prop options must remain unique when serialized as object keys.");
-		}
-	}
-}
-function validateComponentLayers(value, path, definition, diagnostics) {
-	const names = /* @__PURE__ */ new Set();
-	if (!isRecord(value) || Object.keys(value).length === 0) {
-		push(diagnostics, "INVALID_SCHEMA", path, definition, "A native component must declare at least one layer.");
-		return names;
-	}
-	for (const [layerName, layer] of Object.entries(value)) {
-		names.add(layerName);
-		const layerPath = [...path, layerName];
-		if (!isRecord(layer)) {
-			push(diagnostics, "INVALID_SCHEMA", layerPath, definition, `Native layer "${layerName}" must be an object.`);
-			continue;
-		}
-		reportUnknownKeys(layer, LAYER_KEYS, layerPath, definition, diagnostics);
-		if (layer.kind !== "view" && layer.kind !== "text" && layer.kind !== "image") push(diagnostics, "INVALID_SCHEMA", [...layerPath, "kind"], definition, `Native layer "${layerName}" must use view, text, or image styles.`);
-		if (layer.styleProp !== void 0 && (typeof layer.styleProp !== "string" || layer.styleProp.length === 0)) push(diagnostics, "INVALID_SCHEMA", [...layerPath, "styleProp"], definition, "A public style prop name must be a non-empty string.");
-	}
-	return names;
-}
-function validateComponentConfig(value, path, definition, layerNames, diagnostics) {
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", path, definition, "Native component styles must be an object.");
-		return;
-	}
-	reportUnknownKeys(value, COMPONENT_CONFIG_KEYS, path, definition, diagnostics);
-	validateLayerStyleMap(value.base, [...path, "base"], definition, layerNames, diagnostics);
-	for (const key of ["variants", "booleans"]) {
-		const groups = value[key];
-		if (groups === void 0) continue;
-		if (!isRecord(groups)) {
-			push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `${key} must be a record.`);
-			continue;
-		}
-		for (const [propName, values] of Object.entries(groups)) {
-			if (!isRecord(values)) {
-				push(diagnostics, "INVALID_SCHEMA", [
-					...path,
-					key,
-					propName
-				], definition, `${key} styles for "${propName}" must be an option record.`);
-				continue;
-			}
-			for (const [optionName, styles] of Object.entries(values)) validateLayerStyleMap(styles, [
-				...path,
-				key,
-				propName,
-				optionName
-			], definition, layerNames, diagnostics);
-		}
-	}
-	if (value.runtimeStates !== void 0) if (!isRecord(value.runtimeStates)) push(diagnostics, "INVALID_SCHEMA", [...path, "runtimeStates"], definition, "Native runtimeStates must be a record.");
-	else for (const [stateName, styles] of Object.entries(value.runtimeStates)) validateLayerStyleMap(styles, [
-		...path,
-		"runtimeStates",
-		stateName
-	], definition, layerNames, diagnostics);
-	if (value.values !== void 0) if (!isRecord(value.values)) push(diagnostics, "INVALID_SCHEMA", [...path, "values"], definition, "Native named values must be a record.");
-	else for (const [name, namedValue] of Object.entries(value.values)) validateNativeValue(namedValue, [
-		...path,
-		"values",
-		name
-	], definition, diagnostics, true);
-}
-function validateLayerStyleMap(value, path, definition, layerNames, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", path, definition, "Native component styles must be a layer record.");
-		return;
-	}
-	for (const [layerName, styles] of Object.entries(value)) {
-		if (!layerNames.has(layerName)) {
-			push(diagnostics, "INVALID_REFERENCE", [...path, layerName], definition, `Native layer "${layerName}" is not declared by this component.`);
-			continue;
-		}
-		if (!isRecord(styles)) {
-			push(diagnostics, "INVALID_SCHEMA", [...path, layerName], definition, `Styles for layer "${layerName}" must be an object.`);
-			continue;
-		}
-		for (const [property, styleValue] of Object.entries(styles)) validateComponentStyleValue(styleValue, [
-			...path,
-			layerName,
-			property
-		], definition, diagnostics);
-	}
-}
-function validateComponentStyleValue(value, path, definition, diagnostics) {
-	if (Array.isArray(value)) {
-		value.forEach((entry, index) => {
-			validateComponentStyleValue(entry, [...path, index], definition, diagnostics);
-		});
-		return;
-	}
-	if (isRecord(value) && !("__kind" in value)) {
-		for (const [key, nested] of Object.entries(value)) validateComponentStyleValue(nested, [...path, key], definition, diagnostics);
-		return;
-	}
-	validateNativeValue(value, path, definition, diagnostics, true);
-}
-function validateComponentGroups(value, components, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["componentGroups"], { kind: "config" }, "Native componentGroups must be a record.");
-		return;
-	}
-	const registered = isRecord(components) ? components : {};
-	for (const [groupName, group] of Object.entries(value)) {
-		const path = ["componentGroups", groupName];
-		const definition = {
-			kind: "componentGroup",
-			name: groupName
-		};
-		if (!isRecord(group)) {
-			push(diagnostics, "INVALID_SCHEMA", path, definition, `Native component group "${groupName}" must be an object.`);
-			continue;
-		}
-		reportUnknownKeys(group, COMPONENT_GROUP_KEYS, path, definition, diagnostics);
-		if (!Array.isArray(group.components) || group.components.length === 0) push(diagnostics, "INVALID_SCHEMA", [...path, "components"], definition, "A native component group must contain at least one component.");
-		else for (const [index, componentName] of group.components.entries()) if (typeof componentName !== "string" || !(componentName in registered)) push(diagnostics, "INVALID_REFERENCE", [
-			...path,
-			"components",
-			index
-		], definition, `Native component "${String(componentName)}" is not registered.`);
-		for (const key of ["label", "description"]) if (group[key] !== void 0 && typeof group[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `${key} must be a string.`);
-	}
-}
-function validateStyleEngine(value, diagnostics) {
-	if (value !== void 0 && value !== "react-native" && value !== "unistyles") push(diagnostics, "INVALID_SCHEMA", ["styleEngine"], { kind: "config" }, "Native styleEngine must be \"react-native\" or \"unistyles\" when present.");
-}
-function validateNamespace(value, diagnostics) {
-	if (value === void 0) return;
-	if (typeof value !== "string" || value.length === 0 || value.includes(":") || /\s/.test(value)) push(diagnostics, "INVALID_NAMESPACE", ["namespace"], { kind: "config" }, "Native config namespace must be a non-empty string without whitespace or \":\".");
-}
-function validateModes(value, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["modes"], { kind: "config" }, "modes must be a record.");
-		return;
-	}
-	const kindOwners = /* @__PURE__ */ new Map();
-	const modifierOwners = /* @__PURE__ */ new Map();
-	for (const [modeName, options] of Object.entries(value)) {
-		const definition = {
-			kind: "mode",
-			name: modeName
-		};
-		const modePath = ["modes", modeName];
-		if (!isRecord(options)) {
-			push(diagnostics, "INVALID_SCHEMA", modePath, definition, `Mode "${modeName}" must be an option record.`);
-			continue;
-		}
-		if (Object.keys(options).length === 0) push(diagnostics, "INVALID_MODE_CONDITION", modePath, definition, `Native mode "${modeName}" must define at least one appearance or viewport option.`);
-		let modeKind;
-		const conditionValues = /* @__PURE__ */ new Map();
-		for (const [optionName, option] of Object.entries(options)) {
-			const optionPath = [...modePath, optionName];
-			if (!isRecord(option)) {
-				push(diagnostics, "INVALID_SCHEMA", optionPath, definition, `Mode option "${modeName}/${optionName}" must be an object.`);
-				continue;
-			}
-			reportUnknownKeys(option, MODE_OPTION_KEYS, optionPath, definition, diagnostics);
-			for (const key of [
-				"modifier",
-				"label",
-				"description"
-			]) if (option[key] !== void 0 && typeof option[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...optionPath, key], definition, `${key} must be a string when present.`);
-			if (typeof option.modifier === "string" && !option.modifier.startsWith("_")) push(diagnostics, "INVALID_SCHEMA", [...optionPath, "modifier"], definition, "Native mode modifiers must start with \"_\".");
-			for (const key of ["css", "media"]) if (option[key] !== void 0) push(diagnostics, "UNSUPPORTED_NATIVE_FIELD", [...optionPath, key], definition, `Mode option field "${key}" is web-only and is not supported by NativeConfig.`);
-			const hasAppearance = option.appearance !== void 0;
-			if (hasAppearance === (option.minWidth !== void 0)) {
-				push(diagnostics, "INVALID_MODE_CONDITION", optionPath, definition, `Native mode option "${modeName}/${optionName}" must define exactly one condition: appearance or minWidth.`);
-				continue;
-			}
-			const optionKind = hasAppearance ? "appearance" : "viewport";
-			if (modeKind !== void 0 && modeKind !== optionKind) push(diagnostics, "INVALID_MODE_CONDITION", optionPath, definition, `Native mode "${modeName}" cannot mix appearance and viewport options.`);
-			else modeKind = optionKind;
-			let conditionValue;
-			if (hasAppearance) if (typeof option.appearance !== "string" || !APPEARANCES.has(option.appearance)) push(diagnostics, "INVALID_MODE_CONDITION", [...optionPath, "appearance"], definition, "Native appearance must be \"light\" or \"dark\".");
-			else conditionValue = option.appearance;
-			else if (typeof option.minWidth !== "number" || !Number.isFinite(option.minWidth) || option.minWidth < 0) push(diagnostics, "INVALID_MODE_CONDITION", [...optionPath, "minWidth"], definition, "Native minWidth must be a finite, non-negative number.");
-			else conditionValue = option.minWidth;
-			if (conditionValue !== void 0) {
-				const previous = conditionValues.get(conditionValue);
-				if (previous !== void 0) push(diagnostics, "INVALID_MODE_CONDITION", optionPath, definition, `Native mode options "${modeName}/${previous}" and "${modeName}/${optionName}" describe the same condition.`);
-				else conditionValues.set(conditionValue, optionName);
-			}
-			const modifier = typeof option.modifier === "string" ? option.modifier : `_${optionName}`;
-			const previousModifierOwner = modifierOwners.get(modifier);
-			if (previousModifierOwner !== void 0) push(diagnostics, "DUPLICATE_MODIFIER", [...optionPath, "modifier"], definition, `Modifier "${modifier}" is already owned by mode option "${previousModifierOwner}".`);
-			else modifierOwners.set(modifier, `${modeName}/${optionName}`);
-		}
-		if (modeKind !== void 0) {
-			const previousKindOwner = kindOwners.get(modeKind);
-			if (previousKindOwner !== void 0) push(diagnostics, "INVALID_MODE_CONDITION", modePath, definition, `Native ${modeKind} conditions are already registered by mode "${previousKindOwner}".`);
-			else kindOwners.set(modeKind, modeName);
-		}
-	}
-}
-function validateDefaultModes(value, modes, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_DEFAULT_MODE", ["defaultModes"], { kind: "config" }, "defaultModes must be a record of registered mode selections.");
-		return;
-	}
-	const registeredModes = isRecord(modes) ? modes : {};
-	for (const [modeName, optionName] of Object.entries(value)) {
-		const path = ["defaultModes", modeName];
-		const options = registeredModes[modeName];
-		if (!isRecord(options)) {
-			push(diagnostics, "INVALID_DEFAULT_MODE", path, {
-				kind: "mode",
-				name: modeName
-			}, `Default mode "${modeName}" is not registered.`);
-			continue;
-		}
-		if (typeof optionName !== "string" || !isRecord(options[optionName])) push(diagnostics, "INVALID_DEFAULT_MODE", path, {
-			kind: "mode",
-			name: modeName
-		}, `Default mode "${modeName}" must select a registered option.`);
-	}
-}
-function validateAssetGroups(value, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["assetGroups"], { kind: "config" }, "assetGroups must be a record.");
-		return;
-	}
-	for (const [groupName, group] of Object.entries(value)) {
-		const definition = {
-			kind: "asset-group",
-			name: groupName
-		};
-		const groupPath = ["assetGroups", groupName];
-		if (!isRecord(group)) {
-			push(diagnostics, "INVALID_SCHEMA", groupPath, definition, `Asset group "${groupName}" must be an object.`);
-			continue;
-		}
-		reportUnknownKeys(group, ASSET_GROUP_KEYS, groupPath, definition, diagnostics);
-		if (group.assetKind !== "font") push(diagnostics, "INVALID_SCHEMA", [...groupPath, "assetKind"], definition, `Native asset group "${groupName}" must currently use assetKind "font".`);
-		for (const key of ["label", "description"]) if (group[key] !== void 0 && typeof group[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...groupPath, key], definition, `${key} must be a string when present.`);
-		if (!isRecord(group.members)) {
-			push(diagnostics, "INVALID_SCHEMA", [...groupPath, "members"], definition, `Native font asset group "${groupName}" must have a members record.`);
-			continue;
-		}
-		for (const [memberName, member] of Object.entries(group.members)) {
-			const memberDefinition = {
-				kind: "asset",
-				name: `${groupName}/${memberName}`
-			};
-			const memberPath = [
-				...groupPath,
-				"members",
-				memberName
-			];
-			if (!isRecord(member)) {
-				push(diagnostics, "INVALID_SCHEMA", memberPath, memberDefinition, `Native font asset "${groupName}/${memberName}" must be an object.`);
-				continue;
-			}
-			reportUnknownKeys(member, ASSET_MEMBER_KEYS, memberPath, memberDefinition, diagnostics);
-			if (typeof member.fontFamily !== "string" || member.fontFamily.length === 0) push(diagnostics, "INVALID_SCHEMA", [...memberPath, "fontFamily"], memberDefinition, `Native font asset "${groupName}/${memberName}" requires a non-empty fontFamily.`);
-		}
-	}
-}
-function validateTokenGroups(value, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", ["tokenGroups"], { kind: "config" }, "tokenGroups must be a record.");
-		return;
-	}
-	for (const [groupName, group] of Object.entries(value)) {
-		const groupDefinition = {
-			kind: "token-group",
-			name: groupName
-		};
-		const groupPath = ["tokenGroups", groupName];
-		if (!isRecord(group)) {
-			push(diagnostics, "INVALID_SCHEMA", groupPath, groupDefinition, `Token group "${groupName}" must be an object.`);
-			continue;
-		}
-		reportUnknownKeys(group, GROUP_KEYS, groupPath, groupDefinition, diagnostics);
-		for (const key of ["label", "description"]) if (group[key] !== void 0 && typeof group[key] !== "string") push(diagnostics, "INVALID_SCHEMA", [...groupPath, key], groupDefinition, `${key} must be a string when present.`);
-		if (!isRecord(group.tokens)) {
-			push(diagnostics, "INVALID_SCHEMA", [...groupPath, "tokens"], groupDefinition, `Token group "${groupName}" must have a tokens record.`);
-			continue;
-		}
-		for (const [tokenName, token] of Object.entries(group.tokens)) validateTokenDefinition(token, [
-			...groupPath,
-			"tokens",
-			tokenName
-		], {
-			kind: "token",
-			name: `${groupName}/${tokenName}`
-		}, diagnostics);
-	}
-}
-function validateTokenDefinition(value, path, definition, diagnostics) {
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", path, definition, `Native token "${definition.name ?? ""}" must be an object.`);
-		return;
-	}
-	if (!("value" in value)) push(diagnostics, "INVALID_SCHEMA", [...path, "value"], definition, `Native token "${definition.name ?? ""}" requires a value.`);
-	else validateNativeValue(value.value, [...path, "value"], definition, diagnostics, true);
-	if (value.type !== void 0 && typeof value.type !== "string") push(diagnostics, "INVALID_SCHEMA", [...path, "type"], definition, "Token type must be a string when present.");
-	validateSystemLink(value.link, [...path, "link"], definition, diagnostics);
-	for (const [key, modifier] of Object.entries(value)) {
-		if (key === "value" || key === "type" || key === "link") continue;
-		if (!key.startsWith("_")) {
-			push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Unknown token definition field "${key}"; modifier fields must start with "_".`);
-			continue;
-		}
-		if (looksLikeTokenDefinition(modifier)) validateTokenDefinition(modifier, [...path, key], definition, diagnostics);
-		else validateNativeValue(modifier, [...path, key], definition, diagnostics, true);
-	}
-}
-function validateSystemLink(value, path, definition, diagnostics) {
-	if (value === void 0) return;
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_SCHEMA", path, definition, "Token link provenance must be an object.");
-		return;
-	}
-	reportUnknownKeys(value, new Set([
-		"kind",
-		"systemId",
-		"systemVersion",
-		"sourceKey"
-	]), path, definition, diagnostics);
-	if (value.kind !== "token") push(diagnostics, "INVALID_SCHEMA", [...path, "kind"], definition, "Token link provenance must use kind \"token\".");
-	for (const key of [
-		"systemId",
-		"systemVersion",
-		"sourceKey"
-	]) if (typeof value[key] !== "string" || value[key].length === 0) push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Token link provenance requires a non-empty ${key}.`);
-}
-function validateNativeValue(value, path, definition, diagnostics, allowOperatingSystem) {
-	if (typeof value === "string" || typeof value === "boolean") return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native numeric values must be finite.");
-		return;
-	}
-	if (!isRecord(value)) {
-		push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native token values must be serializable strings, numbers, booleans, references, supported color expressions, or operatingSystem() values.");
-		return;
-	}
-	if (isTokenRef(value) || isAssetRef(value)) {
-		reportUnknownKeys(value, TOKEN_REF_KEYS, path, definition, diagnostics);
-		if (typeof value.ref !== "string" || value.ref.length === 0) push(diagnostics, "INVALID_REFERENCE", [...path, "ref"], definition, "Reference markers require a non-empty ref string.");
-		return;
-	}
-	if (isOperatingSystemValue(value)) {
-		if (!allowOperatingSystem) {
-			push(diagnostics, "NESTED_OS_VALUE", path, definition, "An operatingSystem() branch cannot contain another operatingSystem() value.");
-			return;
-		}
-		validateOperatingSystem(value, path, definition, diagnostics);
-		return;
-	}
-	if (isMixExpr(value)) {
-		validateMix(value, path, definition, diagnostics);
-		return;
-	}
-	const kind = typeof value.__kind === "string" ? value.__kind : void 0;
-	if (kind === "darken" || kind === "lighten" || kind === "linear-gradient" || kind === "radial-gradient") {
-		push(diagnostics, "UNSUPPORTED_COLOR_EXPRESSION", path, definition, `Color expression "${kind}" does not yet have cross-platform native semantics; use mix(), alpha(), or a resolved native color.`);
-		return;
-	}
-	push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native token values do not support arbitrary objects or arrays.");
-}
-function validateOperatingSystem(value, path, definition, diagnostics) {
-	reportUnknownKeys(value, OS_KEYS, path, definition, diagnostics);
-	if (value.default === void 0 && (value.ios === void 0 || value.android === void 0)) push(diagnostics, "INCOMPLETE_OS_VALUE", path, definition, "operatingSystem() requires a default value or explicit ios and android values.");
-	for (const key of [
-		"default",
-		"ios",
-		"android"
-	]) if (value[key] !== void 0) validateNativeValue(value[key], [...path, key], definition, diagnostics, false);
-}
-function validateMix(value, path, definition, diagnostics) {
-	reportUnknownKeys(value, MIX_KEYS, path, definition, diagnostics);
-	validateColorOperand(value.from, [...path, "from"], definition, diagnostics);
-	validateColorOperand(value.to, [...path, "to"], definition, diagnostics);
-	const amount = typeof value.amount === "string" ? /^(-?(?:\d+(?:\.\d+)?|\.\d+))%$/.exec(value.amount) : null;
-	const amountNumber = amount ? Number(amount[1]) : NaN;
-	if (!Number.isFinite(amountNumber) || amountNumber < 0 || amountNumber > 100) push(diagnostics, "INVALID_NATIVE_VALUE", [...path, "amount"], definition, "mix() amount must be a percentage between 0% and 100%.");
-	if (value.colorSpace !== void 0 && !COLOR_SPACES.has(value.colorSpace)) push(diagnostics, "INVALID_NATIVE_VALUE", [...path, "colorSpace"], definition, `mix() colorSpace "${String(value.colorSpace)}" is unsupported.`);
-}
-function validateColorOperand(value, path, definition, diagnostics) {
-	if (typeof value === "string") return;
-	if (isTokenRef(value)) {
-		validateNativeValue(value, path, definition, diagnostics, false);
-		return;
-	}
-	if (isMixExpr(value)) {
-		validateMix(value, path, definition, diagnostics);
-		return;
-	}
-	push(diagnostics, "INVALID_NATIVE_VALUE", path, definition, "Native color expressions accept color strings, token references, or nested mix() expressions.");
-}
-function validateReferences(config, diagnostics) {
-	const tokenGroups = isRecord(config.tokenGroups) ? config.tokenGroups : {};
-	const tokens = /* @__PURE__ */ new Map();
-	for (const [groupName, group] of Object.entries(tokenGroups)) {
-		if (!isRecord(group) || !isRecord(group.tokens)) continue;
-		for (const [tokenName, definition] of Object.entries(group.tokens)) {
-			if (!isRecord(definition)) continue;
-			tokens.set(`${groupName}/${tokenName}`, {
-				definition,
-				path: [
-					"tokenGroups",
-					groupName,
-					"tokens",
-					tokenName
-				]
-			});
-		}
-	}
-	const assets = isRecord(config.assetGroups) ? config.assetGroups : {};
-	const modifierLookup = createNativeModifierLookup(config.modes);
-	const contexts = buildModifierContexts(config.modes);
-	for (const [tokenRef, token] of tokens) {
-		collectAllReferences(token.definition, token.path, {
-			kind: "token",
-			name: tokenRef
-		}, tokens, assets, diagnostics);
-		for (const modifiers of contexts) resolveTokenContext(tokenRef, modifiers, modifierLookup, tokens, diagnostics, [], token.path);
-	}
-	for (const [componentName, component] of Object.entries(config.components ?? {})) collectComponentReferences(component, ["components", componentName], {
-		kind: "component",
-		name: componentName
-	}, tokens, assets, diagnostics);
-}
-function collectComponentReferences(value, path, definition, tokens, assets, diagnostics) {
-	if (Array.isArray(value)) {
-		value.forEach((entry, index) => {
-			collectComponentReferences(entry, [...path, index], definition, tokens, assets, diagnostics);
-		});
-		return;
-	}
-	if (!isRecord(value)) return;
-	if (isTokenRef(value)) {
-		if (typeof value.ref === "string" && !tokens.has(value.ref)) push(diagnostics, "UNRESOLVED_TOKEN_REFERENCE", path, definition, `Token reference "${value.ref}" does not resolve within this native config.`);
-		return;
-	}
-	if (isAssetRef(value)) {
-		collectAllReferences(value, path, definition, tokens, assets, diagnostics);
-		return;
-	}
-	for (const [key, nested] of Object.entries(value)) collectComponentReferences(nested, [...path, key], definition, tokens, assets, diagnostics);
-}
-function collectAllReferences(value, path, definition, tokens, assets, diagnostics) {
-	walkValues(value, path, (entry, entryPath) => {
-		if (isTokenRef(entry)) {
-			if (typeof entry.ref === "string" && !tokens.has(entry.ref)) push(diagnostics, "UNRESOLVED_TOKEN_REFERENCE", entryPath, definition, `Token reference "${entry.ref}" does not resolve within this native config.`);
-			return;
-		}
-		if (!isAssetRef(entry) || typeof entry.ref !== "string") return;
-		const slash = entry.ref.indexOf("/");
-		const groupName = slash > 0 ? entry.ref.slice(0, slash) : "";
-		const memberName = slash > 0 ? entry.ref.slice(slash + 1) : "";
-		const group = assets[groupName];
-		if (!groupName || !memberName || !group || group.assetKind !== "font" || !isRecord(group.members) || !group.members[memberName]) push(diagnostics, "UNRESOLVED_ASSET_REFERENCE", entryPath, definition, `Asset reference "${entry.ref}" does not resolve to a registered native font asset.`);
-	});
-}
-function resolveTokenContext(ref, activeModes, modifierLookup, tokens, diagnostics, stack, sourcePath) {
-	if (stack.includes(ref)) {
-		const cycle = [...stack.slice(stack.indexOf(ref)), ref].join(" -> ");
-		push(diagnostics, "TOKEN_REFERENCE_CYCLE", sourcePath, {
-			kind: "token",
-			name: stack[0] ?? ref
-		}, `Native token reference cycle detected: ${cycle}.`);
-		return;
-	}
-	const token = tokens.get(ref);
-	if (!token) return;
-	const selected = selectTokenValue(token.definition, token.path, activeModes, modifierLookup);
-	const nextStack = [...stack, ref];
-	walkValues(selected.value, selected.path, (entry, entryPath) => {
-		if (isTokenRef(entry) && typeof entry.ref === "string") resolveTokenContext(entry.ref, activeModes, modifierLookup, tokens, diagnostics, nextStack, entryPath);
-	});
-}
-function selectTokenValue(definition, path, activeModes, modifierLookup) {
-	const selected = resolveOverrideRow(modifierTreeToOverrideRows(definition, modifierLookup), activeModes);
-	if (!selected) return {
-		value: definition.value,
-		path: [...path, "value"]
-	};
-	let source = definition;
-	for (const modifier of selected.sourceModifierPath) source = source[modifier];
-	return {
-		value: selected.value,
-		path: [
-			...path,
-			...selected.sourceModifierPath,
-			...looksLikeTokenDefinition(source) ? ["value"] : []
-		]
-	};
-}
-function buildModifierContexts(modes) {
-	let contexts = [/* @__PURE__ */ new Set()];
-	for (const [modeName, options] of Object.entries(modes ?? {})) {
-		if (!isRecord(options)) continue;
-		const modeRefs = Object.entries(options).filter((entry) => isRecord(entry[1])).map(([optionName]) => `${modeName}.${optionName}`);
-		contexts = contexts.flatMap((context) => [context, ...modeRefs.map((modeRef) => new Set([...context, modeRef]))]);
-	}
-	return contexts;
-}
-function createNativeModifierLookup(modes) {
-	return createModeBackedModifierLookup(Object.entries(modes ?? {}).flatMap(([modeName, options], modeOrder) => {
-		if (!isRecord(options)) return [];
-		return Object.entries(options).flatMap(([optionName, option], optionOrder) => {
-			if (!isRecord(option)) return [];
-			return [{
-				modifier: typeof option.modifier === "string" ? option.modifier : `_${optionName}`,
-				mode: modeName,
-				option: optionName,
-				label: typeof option.label === "string" ? option.label : void 0,
-				modeOrder,
-				optionOrder
-			}];
-		});
-	}));
-}
-function validateModifierOwnership(config, diagnostics) {
-	const owners = /* @__PURE__ */ new Map();
-	if (isRecord(config.modes)) for (const [modeName, options] of Object.entries(config.modes)) {
-		if (!isRecord(options)) continue;
-		for (const [optionName, option] of Object.entries(options)) {
-			if (!isRecord(option)) continue;
-			const modifier = typeof option.modifier === "string" ? option.modifier : `_${optionName}`;
-			if (!owners.has(modifier)) owners.set(modifier, modeName);
-		}
-	}
-	if (!isRecord(config.tokenGroups)) return;
-	for (const [groupName, group] of Object.entries(config.tokenGroups)) {
-		if (!isRecord(group) || !isRecord(group.tokens)) continue;
-		for (const [tokenName, definition] of Object.entries(group.tokens)) {
-			if (!isRecord(definition)) continue;
-			validateDefinitionModifiers(definition, [
-				"tokenGroups",
-				groupName,
-				"tokens",
-				tokenName
-			], {
-				kind: "token",
-				name: `${groupName}/${tokenName}`
-			}, owners, /* @__PURE__ */ new Set(), diagnostics);
-		}
-	}
-}
-function validateDefinitionModifiers(definition, path, tokenDefinition, owners, activeModeGroups, diagnostics) {
-	for (const [modifier, value] of Object.entries(definition)) {
-		if (!modifier.startsWith("_")) continue;
-		const modifierPath = [...path, modifier];
-		const owner = owners.get(modifier);
-		if (owner === void 0) {
-			push(diagnostics, "UNOWNED_MODIFIER", modifierPath, tokenDefinition, `Modifier "${modifier}" is not owned by a registered mode option.`);
-			continue;
-		}
-		if (activeModeGroups.has(owner)) push(diagnostics, "INVALID_MODE_COMBINATION", modifierPath, tokenDefinition, `Compound native token overrides cannot select more than one option from mode "${owner}".`);
-		if (looksLikeTokenDefinition(value)) validateDefinitionModifiers(value, modifierPath, tokenDefinition, owners, new Set([...activeModeGroups, owner]), diagnostics);
-	}
-}
-function walkValues(value, path, visit) {
-	if (!isRecord(value)) return;
-	if (isTokenRef(value) || isAssetRef(value)) {
-		visit(value, path);
-		return;
-	}
-	if (isOperatingSystemValue(value)) {
-		for (const key of [
-			"default",
-			"ios",
-			"android"
-		]) if (value[key] !== void 0) walkValues(value[key], [...path, key], visit);
-		return;
-	}
-	if (isMixExpr(value)) {
-		walkValues(value.from, [...path, "from"], visit);
-		walkValues(value.to, [...path, "to"], visit);
-		return;
-	}
-	if (looksLikeTokenDefinition(value)) {
-		walkValues(value.value, [...path, "value"], visit);
-		for (const [key, nested] of Object.entries(value)) if (key.startsWith("_")) walkValues(nested, [...path, key], visit);
-		return;
-	}
-	for (const [key, nested] of Object.entries(value)) if (key.startsWith("_")) walkValues(nested, [...path, key], visit);
-}
-function looksLikeTokenDefinition(value) {
-	return isRecord(value) && "value" in value && !("__kind" in value);
-}
-function reportUnknownKeys(value, allowed, path, definition, diagnostics) {
-	for (const key of Object.keys(value)) {
-		if (allowed.has(key)) continue;
-		push(diagnostics, "INVALID_SCHEMA", [...path, key], definition, `Unknown native config field "${key}".`);
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function push(diagnostics, code, path, definition, reason) {
-	diagnostics.push({
-		code,
-		severity: "error",
-		path,
-		definition,
-		reason
-	});
-}
-function dedupe(diagnostics) {
-	const seen = /* @__PURE__ */ new Set();
-	return diagnostics.filter((diagnostic) => {
-		const key = `${diagnostic.code}:${diagnostic.path.join(".")}:${diagnostic.reason}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-//#endregion
-export { validateSerializedNativeConfig };