@terrazzo/parser 2.0.0-alpha.7 → 2.0.0-beta.1

package/dist/index.js

@@ -230,29 +230,35 @@ function validateTransformParams({ params, logger, pluginName }) {
 		message: "setTransform() value expected object of strings, received some non-string values"
 	});
 }
+const FALLBACK_PERMUTATION_ID = JSON.stringify({ tzMode: "*" });
 /** Run build stage */
 async function build(tokens, { resolver, sources, logger = new Logger(), config }) {
 	const formats = {};
 	const result = { outputFiles: [] };
-	function getTransforms(params) {
-		if (!params?.format) {
-			logger.warn({
-				group: "plugin",
-				message: "\"format\" missing from getTransforms(), no tokens returned."
-			});
-			return [];
-		}
-		const tokenMatcher = params.id ? wcmatch(Array.isArray(params.id) ? params.id : [params.id]) : null;
-		const modeMatcher = params.mode ? wcmatch(params.mode) : null;
-		return (formats[params.format] ?? []).filter((token) => {
-			if (params.$type) {
-				if (typeof params.$type === "string" && token.token.$type !== params.$type) return false;
-				else if (Array.isArray(params.$type) && !params.$type.some(($type) => token.token.$type === $type)) return false;
+	function getTransforms(plugin) {
+		return function getTransforms$1(params) {
+			if (!params?.format) {
+				logger.warn({
+					group: "plugin",
+					label: plugin,
+					message: "\"format\" missing from getTransforms(), no tokens returned."
+				});
+				return [];
 			}
-			if (params.id && params.id !== "*" && tokenMatcher && !tokenMatcher(token.token.id)) return false;
-			if (modeMatcher && !modeMatcher(token.mode)) return false;
-			return true;
-		});
+			const tokenMatcher = params.id && params.id !== "*" ? wcmatch(params.id) : null;
+			const modeMatcher = params.mode ? wcmatch(params.mode) : null;
+			const permutationID = params.input ? resolver.getPermutationID(params.input) : JSON.stringify({ tzMode: "*" });
+			return (formats[params.format]?.[permutationID] ?? []).filter((token) => {
+				if (params.$type) {
+					if (typeof params.$type === "string" && token.token.$type !== params.$type) return false;
+					else if (Array.isArray(params.$type) && !params.$type.some(($type) => token.token.$type === $type)) return false;
+				}
+				if (tokenMatcher && !tokenMatcher(token.token.id)) return false;
+				if (params.input && token.permutationID !== resolver.getPermutationID(params.input)) return false;
+				if (modeMatcher && !modeMatcher(token.mode)) return false;
+				return true;
+			});
+		};
 	}
 	let transformsLocked = false;
 	const startTransform = performance.now();
@@ -260,7 +266,7 @@ async function build(tokens, { resolver, sources, logger = new Logger(), config
 		context: { logger },
 		tokens,
 		sources,
-		getTransforms,
+		getTransforms: getTransforms(plugin.name),
 		setTransform(id, params) {
 			if (transformsLocked) {
 				logger.warn({
@@ -271,6 +277,7 @@ async function build(tokens, { resolver, sources, logger = new Logger(), config
 				return;
 			}
 			const token = tokens[id];
+			const permutationID = params.input ? resolver.getPermutationID(params.input) : FALLBACK_PERMUTATION_ID;
 			const cleanValue = typeof params.value === "string" ? params.value : { ...params.value };
 			validateTransformParams({
 				logger,
@@ -280,19 +287,27 @@ async function build(tokens, { resolver, sources, logger = new Logger(), config
 				},
 				pluginName: plugin.name
 			});
-			if (!formats[params.format]) formats[params.format] = [];
-			const foundTokenI = formats[params.format].findIndex((t) => id === t.id && (!params.localID || params.localID === t.localID) && (!params.mode || params.mode === t.mode));
-			if (foundTokenI === -1) formats[params.format].push({
+			if (!formats[params.format]) formats[params.format] = {};
+			if (!formats[params.format][permutationID]) formats[params.format][permutationID] = [];
+			let foundTokenI = -1;
+			if (params.mode) foundTokenI = formats[params.format][permutationID].findIndex((t) => id === t.id && (!params.localID || params.localID === t.localID) && params.mode === t.mode);
+			else if (params.input) {
+				if (!formats[params.format][permutationID]) formats[params.format][permutationID] = [];
+				foundTokenI = formats[params.format][permutationID].findIndex((t) => id === t.id && (!params.localID || params.localID === t.localID) && permutationID === t.permutationID);
+			} else foundTokenI = formats[params.format][permutationID].findIndex((t) => id === t.id && (!params.localID || params.localID === t.localID));
+			if (foundTokenI === -1) formats[params.format][permutationID].push({
 				...params,
 				id,
 				value: cleanValue,
 				type: typeof cleanValue === "string" ? SINGLE_VALUE : MULTI_VALUE,
 				mode: params.mode || ".",
-				token: structuredClone(token)
+				token: structuredClone(token),
+				permutationID,
+				input: JSON.parse(permutationID)
 			});
 			else {
-				formats[params.format][foundTokenI].value = cleanValue;
-				formats[params.format][foundTokenI].type = typeof cleanValue === "string" ? SINGLE_VALUE : MULTI_VALUE;
+				formats[params.format][permutationID][foundTokenI].value = cleanValue;
+				formats[params.format][permutationID][foundTokenI].type = typeof cleanValue === "string" ? SINGLE_VALUE : MULTI_VALUE;
 			}
 		},
 		resolver
@@ -312,7 +327,7 @@ async function build(tokens, { resolver, sources, logger = new Logger(), config
 				context: { logger },
 				tokens,
 				sources,
-				getTransforms,
+				getTransforms: getTransforms(plugin.name),
 				resolver,
 				outputFile(filename, contents) {
 					const resolved = new URL(filename, config.outDir);
@@ -341,7 +356,7 @@ async function build(tokens, { resolver, sources, logger = new Logger(), config
 	await Promise.all(config.plugins.map(async (plugin) => plugin.buildEnd?.({
 		context: { logger },
 		tokens,
-		getTransforms,
+		getTransforms: getTransforms(plugin.name),
 		sources,
 		outputFiles: structuredClone(result.outputFiles)
 	})));
@@ -897,262 +912,134 @@ const rule$16 = {
 var required_typography_properties_default = rule$16;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-boolean.ts
-const VALID_BOOLEAN = "core/valid-boolean";
+//#region src/lint/plugin-core/rules/valid-font-family.ts
+const VALID_FONT_FAMILY = "core/valid-font-family";
 const ERROR$9 = "ERROR";
 const rule$15 = {
 	meta: {
-		messages: { [ERROR$9]: "Must be a boolean." },
+		messages: { [ERROR$9]: "Must be a string, or array of strings." },
 		docs: {
-			description: "Require boolean tokens to follow the Terrazzo extension.",
-			url: docsLink(VALID_BOOLEAN)
+			description: "Require fontFamily tokens to follow the format.",
+			url: docsLink(VALID_FONT_FAMILY)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "boolean") continue;
-			validateBoolean(t.originalValue.$value, {
-				node: getObjMember(t.source.node, "$value"),
-				filename: t.source.filename
-			});
-			function validateBoolean(value, { node, filename }) {
-				if (typeof value !== "boolean") report({
+			if (t.aliasOf || !t.originalValue) continue;
+			switch (t.$type) {
+				case "fontFamily":
+					validateFontFamily(t.originalValue.$value, {
+						node: getObjMember(t.source.node, "$value"),
+						filename: t.source.filename
+					});
+					break;
+				case "typography":
+					if (typeof t.originalValue.$value === "object" && t.originalValue.$value.fontFamily) {
+						if (t.partialAliasOf?.fontFamily) continue;
+						const properties = getObjMembers(getObjMember(t.source.node, "$value"));
+						validateFontFamily(t.originalValue.$value.fontFamily, {
+							node: properties.fontFamily,
+							filename: t.source.filename
+						});
+					}
+					break;
+			}
+			function validateFontFamily(value, { node, filename }) {
+				if (typeof value === "string") {
+					if (!value) report({
+						messageId: ERROR$9,
+						node,
+						filename
+					});
+				} else if (Array.isArray(value)) {
+					if (!value.every((v) => v && typeof v === "string")) report({
+						messageId: ERROR$9,
+						node,
+						filename
+					});
+				} else report({
 					messageId: ERROR$9,
-					filename,
-					node
+					node,
+					filename
 				});
 			}
 		}
 	}
 };
-var valid_boolean_default = rule$15;
+var valid_font_family_default = rule$15;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-border.ts
-const VALID_BORDER = "core/valid-border";
+//#region src/lint/plugin-core/rules/valid-font-weight.ts
+const VALID_FONT_WEIGHT = "core/valid-font-weight";
 const ERROR$8 = "ERROR";
-const ERROR_INVALID_PROP$7 = "ERROR_INVALID_PROP";
+const ERROR_STYLE = "ERROR_STYLE";
 const rule$14 = {
 	meta: {
 		messages: {
-			[ERROR$8]: `Border token missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(BORDER_REQUIRED_PROPERTIES)}.`,
-			[ERROR_INVALID_PROP$7]: "Unknown property: {{ key }}."
-		},
-		docs: {
-			description: "Require border tokens to follow the format.",
-			url: docsLink(VALID_BORDER)
-		}
-	},
-	defaultOptions: {},
-	create({ tokens, report }) {
-		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "border") continue;
-			validateBorder(t.originalValue.$value, {
-				node: getObjMember(t.source.node, "$value"),
-				filename: t.source.filename
-			});
-		}
-		function validateBorder(value, { node, filename }) {
-			if (!value || typeof value !== "object" || !BORDER_REQUIRED_PROPERTIES.every((property) => property in value)) report({
-				messageId: ERROR$8,
-				filename,
-				node
-			});
-			else for (const key of Object.keys(value)) if (!BORDER_REQUIRED_PROPERTIES.includes(key)) report({
-				messageId: ERROR_INVALID_PROP$7,
-				data: { key: JSON.stringify(key) },
-				node: getObjMember(node, key) ?? node,
-				filename
-			});
-		}
-	}
-};
-var valid_border_default = rule$14;
-
-//#endregion
-//#region src/lint/plugin-core/rules/valid-color.ts
-const VALID_COLOR = "core/valid-color";
-const ERROR_ALPHA = "ERROR_ALPHA";
-const ERROR_INVALID_COLOR = "ERROR_INVALID_COLOR";
-const ERROR_INVALID_COLOR_SPACE = "ERROR_INVALID_COLOR_SPACE";
-const ERROR_INVALID_COMPONENT_LENGTH = "ERROR_INVALID_COMPONENT_LENGTH";
-const ERROR_INVALID_HEX8 = "ERROR_INVALID_HEX8";
-const ERROR_INVALID_PROP$6 = "ERROR_INVALID_PROP";
-const ERROR_MISSING_COMPONENTS = "ERROR_MISSING_COMPONENTS";
-const ERROR_OBJ_FORMAT = "ERROR_OBJ_FORMAT";
-const ERROR_OUT_OF_RANGE = "ERROR_OUT_OF_RANGE";
-const rule$13 = {
-	meta: {
-		messages: {
-			[ERROR_ALPHA]: `Alpha {{ alpha }} not in range 0 – 1.`,
-			[ERROR_INVALID_COLOR_SPACE]: `Invalid color space: {{ colorSpace }}. Expected ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(Object.keys(COLORSPACE))}`,
-			[ERROR_INVALID_COLOR]: `Could not parse color {{ color }}.`,
-			[ERROR_INVALID_COMPONENT_LENGTH]: "Expected {{ expected }} components, received {{ got }}.",
-			[ERROR_INVALID_HEX8]: `Hex value can’t be semi-transparent.`,
-			[ERROR_INVALID_PROP$6]: `Unknown property {{ key }}.`,
-			[ERROR_MISSING_COMPONENTS]: "Expected components to be array of numbers, received {{ got }}.",
-			[ERROR_OBJ_FORMAT]: "Migrate to the new object format, e.g. \"#ff0000\" → { \"colorSpace\": \"srgb\", \"components\": [1, 0, 0] } }",
-			[ERROR_OUT_OF_RANGE]: `Invalid range for color space {{ colorSpace }}. Expected {{ range }}.`
+			[ERROR$8]: `Must either be a valid number (0 - 999) or a valid font weight: ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(Object.keys(FONT_WEIGHTS))}.`,
+			[ERROR_STYLE]: "Expected style {{ style }}, received {{ value }}."
 		},
 		docs: {
-			description: "Require color tokens to follow the format.",
-			url: docsLink(VALID_COLOR)
+			description: "Require number tokens to follow the format.",
+			url: docsLink(VALID_FONT_WEIGHT)
 		}
 	},
-	defaultOptions: {
-		legacyFormat: false,
-		ignoreRanges: false
-	},
+	defaultOptions: { style: void 0 },
 	create({ tokens, options, report }) {
 		for (const t of Object.values(tokens)) {
 			if (t.aliasOf || !t.originalValue) continue;
 			switch (t.$type) {
-				case "color":
-					validateColor(t.originalValue.$value, {
+				case "fontWeight":
+					validateFontWeight(t.originalValue.$value, {
 						node: getObjMember(t.source.node, "$value"),
 						filename: t.source.filename
 					});
 					break;
-				case "border":
-					if (t.originalValue.$value.color && !isAlias(t.originalValue.$value.color)) validateColor(t.originalValue.$value.color, {
-						node: getObjMember(getObjMember(t.source.node, "$value"), "color"),
-						filename: t.source.filename
-					});
-					break;
-				case "gradient": {
-					const $valueNode = getObjMember(t.source.node, "$value");
-					for (let i = 0; i < t.originalValue.$value.length; i++) {
-						const stop = t.originalValue.$value[i];
-						if (!stop.color || isAlias(stop.color)) continue;
-						validateColor(stop.color, {
-							node: getObjMember($valueNode.elements[i].value, "color"),
-							filename: t.source.filename
-						});
-					}
-					break;
-				}
-				case "shadow": {
-					const $value = Array.isArray(t.originalValue.$value) ? t.originalValue.$value : [t.originalValue.$value];
-					const $valueNode = getObjMember(t.source.node, "$value");
-					for (let i = 0; i < $value.length; i++) {
-						const layer = $value[i];
-						if (!layer.color || isAlias(layer.color)) continue;
-						validateColor(layer.color, {
-							node: $valueNode.type === "Object" ? getObjMember($valueNode, "color") : getObjMember($valueNode.elements[i].value, "color"),
+				case "typography":
+					if (typeof t.originalValue.$value === "object" && t.originalValue.$value.fontWeight) {
+						if (t.partialAliasOf?.fontWeight) continue;
+						const properties = getObjMembers(getObjMember(t.source.node, "$value"));
+						validateFontWeight(t.originalValue.$value.fontWeight, {
+							node: properties.fontWeight,
 							filename: t.source.filename
 						});
 					}
 					break;
-				}
 			}
-			function validateColor(value, { node, filename }) {
-				if (!value) report({
-					messageId: ERROR_INVALID_COLOR,
-					data: { color: JSON.stringify(value) },
-					node,
-					filename
-				});
-				else if (typeof value === "object") {
-					for (const key of Object.keys(value)) if (![
-						"colorSpace",
-						"components",
-						"channels",
-						"hex",
-						"alpha"
-					].includes(key)) report({
-						messageId: ERROR_INVALID_PROP$6,
-						data: { key: JSON.stringify(key) },
-						node: getObjMember(node, key) ?? node,
-						filename
-					});
-					const colorSpace = "colorSpace" in value && typeof value.colorSpace === "string" ? value.colorSpace : void 0;
-					const csData = COLORSPACE[colorSpace] || void 0;
-					if (!("colorSpace" in value) || !csData) {
-						report({
-							messageId: ERROR_INVALID_COLOR_SPACE,
-							data: { colorSpace },
-							node: getObjMember(node, "colorSpace") ?? node,
-							filename
-						});
-						return;
-					}
-					const components = "components" in value ? value.components : void 0;
-					if (Array.isArray(components)) if (csData?.ranges && components?.length === csData.ranges.length) {
-						for (let i = 0; i < components.length; i++) if (!Number.isFinite(components[i]) || components[i] < csData.ranges[i][0] || components[i] > csData.ranges[i][1]) {
-							if (!(colorSpace === "hsl" && components[0] === null) && !(colorSpace === "hwb" && components[0] === null) && !(colorSpace === "lch" && components[2] === null) && !(colorSpace === "oklch" && components[2] === null)) report({
-								messageId: ERROR_OUT_OF_RANGE,
-								data: {
-									colorSpace,
-									range: `[${csData.ranges.map((r) => `${r[0]}–${r[1]}`).join(", ")}]`
-								},
-								node: getObjMember(node, "components") ?? node,
-								filename
-							});
-						}
-					} else report({
-						messageId: ERROR_INVALID_COMPONENT_LENGTH,
+			function validateFontWeight(value, { node, filename }) {
+				if (typeof value === "string") {
+					if (options.style === "numbers") report({
+						messageId: ERROR_STYLE,
 						data: {
-							expected: csData?.ranges.length,
-							got: components?.length ?? 0
+							style: "numbers",
+							value
 						},
-						node: getObjMember(node, "components") ?? node,
+						node,
 						filename
 					});
-					else report({
-						messageId: ERROR_MISSING_COMPONENTS,
-						data: { got: JSON.stringify(components) },
-						node: getObjMember(node, "components") ?? node,
+					else if (!(value in FONT_WEIGHTS)) report({
+						messageId: ERROR$8,
+						node,
 						filename
 					});
-					const alpha = "alpha" in value ? value.alpha : void 0;
-					if (alpha !== void 0 && (typeof alpha !== "number" || alpha < 0 || alpha > 1)) report({
-						messageId: ERROR_ALPHA,
-						data: { alpha },
-						node: getObjMember(node, "alpha") ?? node,
+				} else if (typeof value === "number") {
+					if (options.style === "names") report({
+						messageId: ERROR_STYLE,
+						data: {
+							style: "names",
+							value
+						},
+						node,
 						filename
 					});
-					const hex = "hex" in value ? value.hex : void 0;
-					if (hex) {
-						let color;
-						try {
-							color = parseColor(hex);
-						} catch {
-							report({
-								messageId: ERROR_INVALID_COLOR,
-								data: { color: hex },
-								node: getObjMember(node, "hex") ?? node,
-								filename
-							});
-							return;
-						}
-						if (color.alpha !== 1) report({
-							messageId: ERROR_INVALID_HEX8,
-							data: { color: hex },
-							node: getObjMember(node, "hex") ?? node,
-							filename
-						});
-					}
-				} else if (typeof value === "string") {
-					if (isAlias(value)) return;
-					if (!options.legacyFormat) report({
-						messageId: ERROR_OBJ_FORMAT,
-						data: { color: JSON.stringify(value) },
+					else if (!(value >= 0 && value < 1e3)) report({
+						messageId: ERROR$8,
 						node,
 						filename
 					});
-					else try {
-						parseColor(value);
-					} catch {
-						report({
-							messageId: ERROR_INVALID_COLOR,
-							data: { color: JSON.stringify(value) },
-							node,
-							filename
-						});
-					}
 				} else report({
-					messageId: ERROR_INVALID_COLOR,
+					messageId: ERROR$8,
 					node,
 					filename
 				});
@@ -1160,64 +1047,96 @@ const rule$13 = {
 		}
 	}
 };
-var valid_color_default = rule$13;
+var valid_font_weight_default = rule$14;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-cubic-bezier.ts
-const VALID_CUBIC_BEZIER = "core/valid-cubic-bezier";
-const ERROR$7 = "ERROR";
-const ERROR_X = "ERROR_X";
-const ERROR_Y = "ERROR_Y";
-const rule$12 = {
+//#region src/lint/plugin-core/rules/valid-gradient.ts
+const VALID_GRADIENT = "core/valid-gradient";
+const ERROR_MISSING$1 = "ERROR_MISSING";
+const ERROR_POSITION = "ERROR_POSITION";
+const ERROR_INVALID_PROP$7 = "ERROR_INVALID_PROP";
+const rule$13 = {
 	meta: {
 		messages: {
-			[ERROR$7]: "Expected [number, number, number, number].",
-			[ERROR_X]: "x values must be between 0-1.",
-			[ERROR_Y]: "y values must be a valid number."
+			[ERROR_MISSING$1]: "Must be an array of { color, position } objects.",
+			[ERROR_POSITION]: "Expected number 0-1, received {{ value }}.",
+			[ERROR_INVALID_PROP$7]: "Unknown property {{ key }}."
 		},
 		docs: {
-			description: "Require cubicBezier tokens to follow the format.",
-			url: docsLink(VALID_CUBIC_BEZIER)
+			description: "Require gradient tokens to follow the format.",
+			url: docsLink(VALID_GRADIENT)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue) continue;
-			switch (t.$type) {
-				case "cubicBezier":
-					validateCubicBezier(t.originalValue.$value, {
-						node: getObjMember(t.source.node, "$value"),
-						filename: t.source.filename
+			if (t.aliasOf || !t.originalValue || t.$type !== "gradient") continue;
+			validateGradient(t.originalValue.$value, {
+				node: getObjMember(t.source.node, "$value"),
+				filename: t.source.filename
+			});
+			function validateGradient(value, { node, filename }) {
+				if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+					const stop = value[i];
+					if (!stop || typeof stop !== "object") {
+						report({
+							messageId: ERROR_MISSING$1,
+							node,
+							filename
+						});
+						continue;
+					}
+					for (const property of GRADIENT_REQUIRED_STOP_PROPERTIES) if (!(property in stop)) report({
+						messageId: ERROR_MISSING$1,
+						node: node.elements[i],
+						filename
 					});
-					break;
-				case "transition": if (typeof t.originalValue.$value === "object" && t.originalValue.$value.timingFunction && !isAlias(t.originalValue.$value.timingFunction)) {
-					const $valueNode = getObjMember(t.source.node, "$value");
-					validateCubicBezier(t.originalValue.$value.timingFunction, {
-						node: getObjMember($valueNode, "timingFunction"),
-						filename: t.source.filename
+					for (const key of Object.keys(stop)) if (!GRADIENT_REQUIRED_STOP_PROPERTIES.includes(key)) report({
+						messageId: ERROR_INVALID_PROP$7,
+						data: { key: JSON.stringify(key) },
+						node: node.elements[i],
+						filename
+					});
+					if ("position" in stop && typeof stop.position !== "number" && !isAlias(stop.position)) report({
+						messageId: ERROR_POSITION,
+						data: { value: stop.position },
+						node: getObjMember(node.elements[i].value, "position"),
+						filename
 					});
 				}
+				else report({
+					messageId: ERROR_MISSING$1,
+					node,
+					filename
+				});
 			}
-			function validateCubicBezier(value, { node, filename }) {
-				if (Array.isArray(value) && value.length === 4) {
-					for (const pos of [0, 2]) {
-						if (isAlias(value[pos]) || isPure$ref(value[pos])) continue;
-						if (!(value[pos] >= 0 && value[pos] <= 1)) report({
-							messageId: ERROR_X,
-							node: node.elements[pos],
-							filename
-						});
-					}
-					for (const pos of [1, 3]) {
-						if (isAlias(value[pos]) || isPure$ref(value[pos])) continue;
-						if (typeof value[pos] !== "number") report({
-							messageId: ERROR_Y,
-							node: node.elements[pos],
-							filename
-						});
-					}
-				} else report({
+		}
+	}
+};
+var valid_gradient_default = rule$13;
+
+//#endregion
+//#region src/lint/plugin-core/rules/valid-link.ts
+const VALID_LINK = "core/valid-link";
+const ERROR$7 = "ERROR";
+const rule$12 = {
+	meta: {
+		messages: { [ERROR$7]: "Must be a string." },
+		docs: {
+			description: "Require link tokens to follow the Terrazzo extension.",
+			url: docsLink(VALID_LINK)
+		}
+	},
+	defaultOptions: {},
+	create({ tokens, report }) {
+		for (const t of Object.values(tokens)) {
+			if (t.aliasOf || !t.originalValue || t.$type !== "link") continue;
+			validateLink(t.originalValue.$value, {
+				node: getObjMember(t.source.node, "$value"),
+				filename: t.source.filename
+			});
+			function validateLink(value, { node, filename }) {
+				if (!value || typeof value !== "string") report({
 					messageId: ERROR$7,
 					node,
 					filename
@@ -1226,160 +1145,44 @@ const rule$12 = {
 		}
 	}
 };
-var valid_cubic_bezier_default = rule$12;
+var valid_link_default = rule$12;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-dimension.ts
-const VALID_DIMENSION = "core/valid-dimension";
-const ERROR_FORMAT$1 = "ERROR_FORMAT";
-const ERROR_INVALID_PROP$5 = "ERROR_INVALID_PROP";
-const ERROR_LEGACY$1 = "ERROR_LEGACY";
-const ERROR_UNIT$1 = "ERROR_UNIT";
-const ERROR_VALUE$1 = "ERROR_VALUE";
+//#region src/lint/plugin-core/rules/valid-number.ts
+const VALID_NUMBER = "core/valid-number";
+const ERROR_NAN = "ERROR_NAN";
 const rule$11 = {
 	meta: {
-		messages: {
-			[ERROR_FORMAT$1]: "Invalid dimension: {{ value }}. Expected object with \"value\" and \"unit\".",
-			[ERROR_LEGACY$1]: "Migrate to the new object format: { \"value\": 10, \"unit\": \"px\" }.",
-			[ERROR_UNIT$1]: "Unit {{ unit }} not allowed. Expected {{ allowed }}.",
-			[ERROR_INVALID_PROP$5]: "Unknown property {{ key }}.",
-			[ERROR_VALUE$1]: "Expected number, received {{ value }}."
-		},
+		messages: { [ERROR_NAN]: "Must be a number." },
 		docs: {
-			description: "Require dimension tokens to follow the format",
-			url: docsLink(VALID_DIMENSION)
+			description: "Require number tokens to follow the format.",
+			url: docsLink(VALID_NUMBER)
 		}
 	},
-	defaultOptions: {
-		legacyFormat: false,
-		allowedUnits: [
-			"px",
-			"em",
-			"rem"
-		]
-	},
-	create({ tokens, options, report }) {
+	defaultOptions: {},
+	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
 			if (t.aliasOf || !t.originalValue) continue;
 			switch (t.$type) {
-				case "dimension":
-					validateDimension(t.originalValue.$value, {
+				case "number":
+					validateNumber(t.originalValue.$value, {
 						node: getObjMember(t.source.node, "$value"),
 						filename: t.source.filename
 					});
 					break;
-				case "strokeStyle":
-					if (typeof t.originalValue.$value === "object" && Array.isArray(t.originalValue.$value.dashArray)) {
-						const dashArray = getObjMember(getObjMember(t.source.node, "$value"), "dashArray");
-						for (let i = 0; i < t.originalValue.$value.dashArray.length; i++) {
-							if (isAlias(t.originalValue.$value.dashArray[i])) continue;
-							validateDimension(t.originalValue.$value.dashArray[i], {
-								node: dashArray.elements[i].value,
-								filename: t.source.filename
-							});
-						}
-					}
-					break;
-				case "border": {
+				case "typography": {
 					const $valueNode = getObjMember(t.source.node, "$value");
 					if (typeof t.originalValue.$value === "object") {
-						if (t.originalValue.$value.width && !isAlias(t.originalValue.$value.width)) validateDimension(t.originalValue.$value.width, {
-							node: getObjMember($valueNode, "width"),
+						if (t.originalValue.$value.lineHeight && !isAlias(t.originalValue.$value.lineHeight) && typeof t.originalValue.$value.lineHeight !== "object") validateNumber(t.originalValue.$value.lineHeight, {
+							node: getObjMember($valueNode, "lineHeight"),
 							filename: t.source.filename
 						});
-						if (typeof t.originalValue.$value.style === "object" && Array.isArray(t.originalValue.$value.style.dashArray)) {
-							const dashArray = getObjMember(getObjMember($valueNode, "style"), "dashArray");
-							for (let i = 0; i < t.originalValue.$value.style.dashArray.length; i++) {
-								if (isAlias(t.originalValue.$value.style.dashArray[i])) continue;
-								validateDimension(t.originalValue.$value.style.dashArray[i], {
-									node: dashArray.elements[i].value,
-									filename: t.source.filename
-								});
-							}
-						}
-					}
-					break;
-				}
-				case "shadow":
-					if (t.originalValue.$value && typeof t.originalValue.$value === "object") {
-						const $valueNode = getObjMember(t.source.node, "$value");
-						const valueArray = Array.isArray(t.originalValue.$value) ? t.originalValue.$value : [t.originalValue.$value];
-						for (let i = 0; i < valueArray.length; i++) {
-							const node = $valueNode.type === "Array" ? $valueNode.elements[i].value : $valueNode;
-							for (const property of [
-								"offsetX",
-								"offsetY",
-								"blur",
-								"spread"
-							]) {
-								if (isAlias(valueArray[i][property])) continue;
-								validateDimension(valueArray[i][property], {
-									node: getObjMember(node, property),
-									filename: t.source.filename
-								});
-							}
-						}
-					}
-					break;
-				case "typography": {
-					const $valueNode = getObjMember(t.source.node, "$value");
-					if (typeof t.originalValue.$value === "object") {
-						for (const property of [
-							"fontSize",
-							"lineHeight",
-							"letterSpacing"
-						]) if (property in t.originalValue.$value) {
-							if (isAlias(t.originalValue.$value[property]) || property === "lineHeight" && typeof t.originalValue.$value[property] === "number") continue;
-							validateDimension(t.originalValue.$value[property], {
-								node: getObjMember($valueNode, property),
-								filename: t.source.filename
-							});
-						}
 					}
-					break;
 				}
 			}
-			function validateDimension(value, { node, filename }) {
-				if (value && typeof value === "object") {
-					for (const key of Object.keys(value)) if (!["value", "unit"].includes(key)) report({
-						messageId: ERROR_INVALID_PROP$5,
-						data: { key: JSON.stringify(key) },
-						node: getObjMember(node, key) ?? node,
-						filename
-					});
-					const { unit, value: numValue } = value;
-					if (!("value" in value || "unit" in value)) {
-						report({
-							messageId: ERROR_FORMAT$1,
-							data: { value },
-							node,
-							filename
-						});
-						return;
-					}
-					if (!options.allowedUnits.includes(unit)) report({
-						messageId: ERROR_UNIT$1,
-						data: {
-							unit,
-							allowed: new Intl.ListFormat("en-us", { type: "disjunction" }).format(options.allowedUnits)
-						},
-						node: getObjMember(node, "unit") ?? node,
-						filename
-					});
-					if (!Number.isFinite(numValue)) report({
-						messageId: ERROR_VALUE$1,
-						data: { value },
-						node: getObjMember(node, "value") ?? node,
-						filename
-					});
-				} else if (typeof value === "string" && !options.legacyFormat) report({
-					messageId: ERROR_LEGACY$1,
-					node,
-					filename
-				});
-				else report({
-					messageId: ERROR_FORMAT$1,
-					data: { value },
+			function validateNumber(value, { node, filename }) {
+				if (typeof value !== "number" || Number.isNaN(value)) report({
+					messageId: ERROR_NAN,
 					node,
 					filename
 				});
@@ -1387,150 +1190,74 @@ const rule$11 = {
 		}
 	}
 };
-var valid_dimension_default = rule$11;
+var valid_number_default = rule$11;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-duration.ts
-const VALID_DURATION = "core/valid-duration";
-const ERROR_FORMAT = "ERROR_FORMAT";
-const ERROR_INVALID_PROP$4 = "ERROR_INVALID_PROP";
-const ERROR_LEGACY = "ERROR_LEGACY";
-const ERROR_UNIT = "ERROR_UNIT";
-const ERROR_VALUE = "ERROR_VALUE";
+//#region src/lint/plugin-core/rules/valid-shadow.ts
+const VALID_SHADOW = "core/valid-shadow";
+const ERROR$6 = "ERROR";
+const ERROR_INVALID_PROP$6 = "ERROR_INVALID_PROP";
 const rule$10 = {
 	meta: {
 		messages: {
-			[ERROR_FORMAT]: "Migrate to the new object format: { \"value\": 2, \"unit\": \"ms\" }.",
-			[ERROR_LEGACY]: "Migrate to the new object format: { \"value\": 10, \"unit\": \"px\" }.",
-			[ERROR_INVALID_PROP$4]: "Unknown property: {{ key }}.",
-			[ERROR_UNIT]: "Unknown unit {{ unit }}. Expected \"ms\" or \"s\".",
-			[ERROR_VALUE]: "Expected number, received {{ value }}."
+			[ERROR$6]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(SHADOW_REQUIRED_PROPERTIES)}.`,
+			[ERROR_INVALID_PROP$6]: "Unknown property {{ key }}."
 		},
 		docs: {
-			description: "Require duration tokens to follow the format",
-			url: docsLink(VALID_DURATION)
+			description: "Require shadow tokens to follow the format.",
+			url: docsLink(VALID_SHADOW)
 		}
 	},
-	defaultOptions: {
-		legacyFormat: false,
-		unknownUnits: false
-	},
-	create({ tokens, options, report }) {
+	defaultOptions: {},
+	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue) continue;
-			switch (t.$type) {
-				case "duration":
-					validateDuration(t.originalValue.$value, {
-						node: getObjMember(t.source.node, "$value"),
-						filename: t.source.filename
-					});
-					break;
-				case "transition":
-					if (typeof t.originalValue.$value === "object") {
-						const $valueNode = getObjMember(t.source.node, "$value");
-						for (const property of ["duration", "delay"]) if (t.originalValue.$value[property] && !isAlias(t.originalValue.$value[property])) validateDuration(t.originalValue.$value[property], {
-							node: getObjMember($valueNode, property),
-							filename: t.source.filename
-						});
-					}
-					break;
-			}
-			function validateDuration(value, { node, filename }) {
-				if (value && typeof value === "object") {
-					for (const key of Object.keys(value)) if (!["value", "unit"].includes(key)) report({
-						messageId: ERROR_INVALID_PROP$4,
-						data: { key: JSON.stringify(key) },
-						node: getObjMember(node, key) ?? node,
-						filename
-					});
-					const { unit, value: numValue } = value;
-					if (!("value" in value || "unit" in value)) {
-						report({
-							messageId: ERROR_FORMAT,
-							data: { value },
-							node,
-							filename
-						});
-						return;
-					}
-					if (!options.unknownUnits && !["ms", "s"].includes(unit)) report({
-						messageId: ERROR_UNIT,
-						data: { unit },
-						node: getObjMember(node, "unit") ?? node,
-						filename
-					});
-					if (!Number.isFinite(numValue)) report({
-						messageId: ERROR_VALUE,
-						data: { value },
-						node: getObjMember(node, "value") ?? node,
-						filename
-					});
-				} else if (typeof value === "string" && !options.legacyFormat) report({
-					messageId: ERROR_FORMAT,
+			if (t.aliasOf || !t.originalValue || t.$type !== "shadow") continue;
+			validateShadow(t.originalValue.$value, {
+				node: getObjMember(t.source.node, "$value"),
+				filename: t.source.filename
+			});
+			function validateShadow(value, { node, filename }) {
+				const wrappedValue = Array.isArray(value) ? value : [value];
+				for (let i = 0; i < wrappedValue.length; i++) if (!wrappedValue[i] || typeof wrappedValue[i] !== "object" || !SHADOW_REQUIRED_PROPERTIES.every((property) => property in wrappedValue[i])) report({
+					messageId: ERROR$6,
 					node,
 					filename
 				});
-				else report({
-					messageId: ERROR_FORMAT,
-					data: { value },
-					node,
+				else for (const key of Object.keys(wrappedValue[i])) if (![...SHADOW_REQUIRED_PROPERTIES, "inset"].includes(key)) report({
+					messageId: ERROR_INVALID_PROP$6,
+					data: { key: JSON.stringify(key) },
+					node: getObjMember(node.type === "Array" ? node.elements[i].value : node, key),
 					filename
 				});
 			}
 		}
 	}
 };
-var valid_duration_default = rule$10;
+var valid_shadow_default = rule$10;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-font-family.ts
-const VALID_FONT_FAMILY = "core/valid-font-family";
-const ERROR$6 = "ERROR";
+//#region src/lint/plugin-core/rules/valid-string.ts
+const VALID_STRING = "core/valid-string";
+const ERROR$5 = "ERROR";
 const rule$9 = {
 	meta: {
-		messages: { [ERROR$6]: "Must be a string, or array of strings." },
+		messages: { [ERROR$5]: "Must be a string." },
 		docs: {
-			description: "Require fontFamily tokens to follow the format.",
-			url: docsLink(VALID_FONT_FAMILY)
+			description: "Require string tokens to follow the Terrazzo extension.",
+			url: docsLink(VALID_STRING)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue) continue;
-			switch (t.$type) {
-				case "fontFamily":
-					validateFontFamily(t.originalValue.$value, {
-						node: getObjMember(t.source.node, "$value"),
-						filename: t.source.filename
-					});
-					break;
-				case "typography":
-					if (typeof t.originalValue.$value === "object" && t.originalValue.$value.fontFamily) {
-						if (t.partialAliasOf?.fontFamily) continue;
-						const properties = getObjMembers(getObjMember(t.source.node, "$value"));
-						validateFontFamily(t.originalValue.$value.fontFamily, {
-							node: properties.fontFamily,
-							filename: t.source.filename
-						});
-					}
-					break;
-			}
-			function validateFontFamily(value, { node, filename }) {
-				if (typeof value === "string") {
-					if (!value) report({
-						messageId: ERROR$6,
-						node,
-						filename
-					});
-				} else if (Array.isArray(value)) {
-					if (!value.every((v) => v && typeof v === "string")) report({
-						messageId: ERROR$6,
-						node,
-						filename
-					});
-				} else report({
-					messageId: ERROR$6,
+			if (t.aliasOf || !t.originalValue || t.$type !== "string") continue;
+			validateString(t.originalValue.$value, {
+				node: getObjMember(t.source.node, "$value"),
+				filename: t.source.filename
+			});
+			function validateString(value, { node, filename }) {
+				if (typeof value !== "string") report({
+					messageId: ERROR$5,
 					node,
 					filename
 				});
@@ -1538,79 +1265,83 @@ const rule$9 = {
 		}
 	}
 };
-var valid_font_family_default = rule$9;
+var valid_string_default = rule$9;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-font-weight.ts
-const VALID_FONT_WEIGHT = "core/valid-font-weight";
-const ERROR$5 = "ERROR";
-const ERROR_STYLE = "ERROR_STYLE";
+//#region src/lint/plugin-core/rules/valid-stroke-style.ts
+const VALID_STROKE_STYLE = "core/valid-stroke-style";
+const ERROR_STR = "ERROR_STR";
+const ERROR_OBJ = "ERROR_OBJ";
+const ERROR_LINE_CAP = "ERROR_LINE_CAP";
+const ERROR_INVALID_PROP$5 = "ERROR_INVALID_PROP";
 const rule$8 = {
 	meta: {
 		messages: {
-			[ERROR$5]: `Must either be a valid number (0 - 999) or a valid font weight: ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(Object.keys(FONT_WEIGHTS))}.`,
-			[ERROR_STYLE]: "Expected style {{ style }}, received {{ value }}."
+			[ERROR_STR]: `Value most be one of ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(STROKE_STYLE_STRING_VALUES)}.`,
+			[ERROR_OBJ]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
+			[ERROR_LINE_CAP]: `lineCap must be one of ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(STROKE_STYLE_LINE_CAP_VALUES)}.`,
+			[ERROR_INVALID_PROP$5]: "Unknown property: {{ key }}."
 		},
 		docs: {
-			description: "Require number tokens to follow the format.",
-			url: docsLink(VALID_FONT_WEIGHT)
+			description: "Require strokeStyle tokens to follow the format.",
+			url: docsLink(VALID_STROKE_STYLE)
 		}
 	},
-	defaultOptions: { style: void 0 },
-	create({ tokens, options, report }) {
+	defaultOptions: {},
+	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
 			if (t.aliasOf || !t.originalValue) continue;
 			switch (t.$type) {
-				case "fontWeight":
-					validateFontWeight(t.originalValue.$value, {
+				case "strokeStyle":
+					validateStrokeStyle(t.originalValue.$value, {
 						node: getObjMember(t.source.node, "$value"),
 						filename: t.source.filename
 					});
 					break;
-				case "typography":
-					if (typeof t.originalValue.$value === "object" && t.originalValue.$value.fontWeight) {
-						if (t.partialAliasOf?.fontWeight) continue;
-						const properties = getObjMembers(getObjMember(t.source.node, "$value"));
-						validateFontWeight(t.originalValue.$value.fontWeight, {
-							node: properties.fontWeight,
+				case "border":
+					if (t.originalValue.$value && typeof t.originalValue.$value === "object") {
+						const $valueNode = getObjMember(t.source.node, "$value");
+						if (t.originalValue.$value.style) validateStrokeStyle(t.originalValue.$value.style, {
+							node: getObjMember($valueNode, "style"),
 							filename: t.source.filename
 						});
 					}
 					break;
 			}
-			function validateFontWeight(value, { node, filename }) {
+			function validateStrokeStyle(value, { node, filename }) {
 				if (typeof value === "string") {
-					if (options.style === "numbers") report({
-						messageId: ERROR_STYLE,
-						data: {
-							style: "numbers",
-							value
-						},
+					if (!isAlias(value) && !STROKE_STYLE_STRING_VALUES.includes(value)) {
+						report({
+							messageId: ERROR_STR,
+							node,
+							filename
+						});
+						return;
+					}
+				} else if (value && typeof value === "object") {
+					if (!STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES.every((property) => property in value)) report({
+						messageId: ERROR_OBJ,
 						node,
 						filename
 					});
-					else if (!(value in FONT_WEIGHTS)) report({
-						messageId: ERROR$5,
-						node,
+					if (!Array.isArray(value.dashArray)) report({
+						messageId: ERROR_OBJ,
+						node: getObjMember(node, "dashArray"),
 						filename
 					});
-				} else if (typeof value === "number") {
-					if (options.style === "names") report({
-						messageId: ERROR_STYLE,
-						data: {
-							style: "names",
-							value
-						},
-						node,
+					if (!STROKE_STYLE_LINE_CAP_VALUES.includes(value.lineCap)) report({
+						messageId: ERROR_OBJ,
+						node: getObjMember(node, "lineCap"),
 						filename
 					});
-					else if (!(value >= 0 && value < 1e3)) report({
-						messageId: ERROR$5,
-						node,
+					for (const key of Object.keys(value)) if (!["dashArray", "lineCap"].includes(key)) report({
+						messageId: ERROR_INVALID_PROP$5,
+						data: { key: JSON.stringify(key) },
+						node: getObjMember(node, key),
 						filename
 					});
 				} else report({
-					messageId: ERROR$5,
+					messageId: ERROR_OBJ,
 					node,
 					filename
 				});
@@ -1618,97 +1349,92 @@ const rule$8 = {
 		}
 	}
 };
-var valid_font_weight_default = rule$8;
+var valid_stroke_style_default = rule$8;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-gradient.ts
-const VALID_GRADIENT = "core/valid-gradient";
-const ERROR_MISSING$1 = "ERROR_MISSING";
-const ERROR_POSITION = "ERROR_POSITION";
-const ERROR_INVALID_PROP$3 = "ERROR_INVALID_PROP";
+//#region src/lint/plugin-core/rules/valid-transition.ts
+const VALID_TRANSITION = "core/valid-transition";
+const ERROR$4 = "ERROR";
+const ERROR_INVALID_PROP$4 = "ERROR_INVALID_PROP";
 const rule$7 = {
 	meta: {
 		messages: {
-			[ERROR_MISSING$1]: "Must be an array of { color, position } objects.",
-			[ERROR_POSITION]: "Expected number 0-1, received {{ value }}.",
-			[ERROR_INVALID_PROP$3]: "Unknown property {{ key }}."
+			[ERROR$4]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
+			[ERROR_INVALID_PROP$4]: "Unknown property: {{ key }}."
 		},
 		docs: {
-			description: "Require gradient tokens to follow the format.",
-			url: docsLink(VALID_GRADIENT)
+			description: "Require transition tokens to follow the format.",
+			url: docsLink(VALID_TRANSITION)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "gradient") continue;
-			validateGradient(t.originalValue.$value, {
+			if (t.aliasOf || !t.originalValue || t.$type !== "transition") continue;
+			validateTransition(t.originalValue.$value, {
 				node: getObjMember(t.source.node, "$value"),
 				filename: t.source.filename
 			});
-			function validateGradient(value, { node, filename }) {
-				if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
-					const stop = value[i];
-					if (!stop || typeof stop !== "object") {
-						report({
-							messageId: ERROR_MISSING$1,
-							node,
-							filename
-						});
-						continue;
-					}
-					for (const property of GRADIENT_REQUIRED_STOP_PROPERTIES) if (!(property in stop)) report({
-						messageId: ERROR_MISSING$1,
-						node: node.elements[i],
-						filename
-					});
-					for (const key of Object.keys(stop)) if (!GRADIENT_REQUIRED_STOP_PROPERTIES.includes(key)) report({
-						messageId: ERROR_INVALID_PROP$3,
-						data: { key: JSON.stringify(key) },
-						node: node.elements[i],
-						filename
-					});
-					if ("position" in stop && typeof stop.position !== "number" && !isAlias(stop.position)) report({
-						messageId: ERROR_POSITION,
-						data: { value: stop.position },
-						node: getObjMember(node.elements[i].value, "position"),
-						filename
-					});
-				}
-				else report({
-					messageId: ERROR_MISSING$1,
-					node,
-					filename
-				});
-			}
+		}
+		function validateTransition(value, { node, filename }) {
+			if (!value || typeof value !== "object" || !TRANSITION_REQUIRED_PROPERTIES.every((property) => property in value)) report({
+				messageId: ERROR$4,
+				node,
+				filename
+			});
+			else for (const key of Object.keys(value)) if (!TRANSITION_REQUIRED_PROPERTIES.includes(key)) report({
+				messageId: ERROR_INVALID_PROP$4,
+				data: { key: JSON.stringify(key) },
+				node: getObjMember(node, key),
+				filename
+			});
 		}
 	}
 };
-var valid_gradient_default = rule$7;
+var valid_transition_default = rule$7;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-link.ts
-const VALID_LINK = "core/valid-link";
-const ERROR$4 = "ERROR";
+//#region src/lint/plugin-core/rules/valid-typography.ts
+const VALID_TYPOGRAPHY = "core/valid-typography";
+const ERROR$3 = "ERROR";
+const ERROR_MISSING = "ERROR_MISSING";
 const rule$6 = {
 	meta: {
-		messages: { [ERROR$4]: "Must be a string." },
+		messages: {
+			[ERROR$3]: `Expected object, received {{ value }}.`,
+			[ERROR_MISSING]: `Missing required property "{{ property }}".`
+		},
 		docs: {
-			description: "Require link tokens to follow the Terrazzo extension.",
-			url: docsLink(VALID_LINK)
+			description: "Require typography tokens to follow the format.",
+			url: docsLink(VALID_TYPOGRAPHY)
 		}
 	},
-	defaultOptions: {},
-	create({ tokens, report }) {
+	defaultOptions: { requiredProperties: [
+		"fontFamily",
+		"fontSize",
+		"fontWeight",
+		"letterSpacing",
+		"lineHeight"
+	] },
+	create({ tokens, options, report }) {
+		const isIgnored = options.ignore ? wcmatch(options.ignore) : () => false;
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "link") continue;
-			validateLink(t.originalValue.$value, {
+			if (t.aliasOf || !t.originalValue || t.$type !== "typography" || isIgnored(t.id)) continue;
+			validateTypography(t.originalValue.$value, {
 				node: getObjMember(t.source.node, "$value"),
 				filename: t.source.filename
 			});
-			function validateLink(value, { node, filename }) {
-				if (!value || typeof value !== "string") report({
-					messageId: ERROR$4,
+			function validateTypography(value, { node, filename }) {
+				if (value && typeof value === "object") {
+					for (const property of options.requiredProperties) if (!(property in value)) report({
+						messageId: ERROR_MISSING,
+						data: { property },
+						node,
+						filename
+					});
+				} else report({
+					messageId: ERROR$3,
+					data: { value: JSON.stringify(value) },
 					node,
 					filename
 				});
@@ -1716,203 +1442,265 @@ const rule$6 = {
 		}
 	}
 };
-var valid_link_default = rule$6;
+var valid_typography_default = rule$6;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-number.ts
-const VALID_NUMBER = "core/valid-number";
-const ERROR_NAN = "ERROR_NAN";
+//#region src/lint/plugin-core/rules/valid-boolean.ts
+const VALID_BOOLEAN = "core/valid-boolean";
+const ERROR$2 = "ERROR";
 const rule$5 = {
 	meta: {
-		messages: { [ERROR_NAN]: "Must be a number." },
+		messages: { [ERROR$2]: "Must be a boolean." },
 		docs: {
-			description: "Require number tokens to follow the format.",
-			url: docsLink(VALID_NUMBER)
+			description: "Require boolean tokens to follow the Terrazzo extension.",
+			url: docsLink(VALID_BOOLEAN)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue) continue;
-			switch (t.$type) {
-				case "number":
-					validateNumber(t.originalValue.$value, {
-						node: getObjMember(t.source.node, "$value"),
-						filename: t.source.filename
-					});
-					break;
-				case "typography": {
-					const $valueNode = getObjMember(t.source.node, "$value");
-					if (typeof t.originalValue.$value === "object") {
-						if (t.originalValue.$value.lineHeight && !isAlias(t.originalValue.$value.lineHeight) && typeof t.originalValue.$value.lineHeight !== "object") validateNumber(t.originalValue.$value.lineHeight, {
-							node: getObjMember($valueNode, "lineHeight"),
-							filename: t.source.filename
-						});
-					}
-				}
-			}
-			function validateNumber(value, { node, filename }) {
-				if (typeof value !== "number" || Number.isNaN(value)) report({
-					messageId: ERROR_NAN,
-					node,
-					filename
+			if (t.aliasOf || !t.originalValue || t.$type !== "boolean") continue;
+			validateBoolean(t.originalValue.$value, {
+				node: getObjMember(t.source.node, "$value"),
+				filename: t.source.filename
+			});
+			function validateBoolean(value, { node, filename }) {
+				if (typeof value !== "boolean") report({
+					messageId: ERROR$2,
+					filename,
+					node
 				});
 			}
 		}
 	}
 };
-var valid_number_default = rule$5;
+var valid_boolean_default = rule$5;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-shadow.ts
-const VALID_SHADOW = "core/valid-shadow";
-const ERROR$3 = "ERROR";
-const ERROR_INVALID_PROP$2 = "ERROR_INVALID_PROP";
+//#region src/lint/plugin-core/rules/valid-border.ts
+const VALID_BORDER = "core/valid-border";
+const ERROR$1 = "ERROR";
+const ERROR_INVALID_PROP$3 = "ERROR_INVALID_PROP";
 const rule$4 = {
 	meta: {
 		messages: {
-			[ERROR$3]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(SHADOW_REQUIRED_PROPERTIES)}.`,
-			[ERROR_INVALID_PROP$2]: "Unknown property {{ key }}."
+			[ERROR$1]: `Border token missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(BORDER_REQUIRED_PROPERTIES)}.`,
+			[ERROR_INVALID_PROP$3]: "Unknown property: {{ key }}."
 		},
 		docs: {
-			description: "Require shadow tokens to follow the format.",
-			url: docsLink(VALID_SHADOW)
+			description: "Require border tokens to follow the format.",
+			url: docsLink(VALID_BORDER)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "shadow") continue;
-			validateShadow(t.originalValue.$value, {
+			if (t.aliasOf || !t.originalValue || t.$type !== "border") continue;
+			validateBorder(t.originalValue.$value, {
 				node: getObjMember(t.source.node, "$value"),
 				filename: t.source.filename
 			});
-			function validateShadow(value, { node, filename }) {
-				const wrappedValue = Array.isArray(value) ? value : [value];
-				for (let i = 0; i < wrappedValue.length; i++) if (!wrappedValue[i] || typeof wrappedValue[i] !== "object" || !SHADOW_REQUIRED_PROPERTIES.every((property) => property in wrappedValue[i])) report({
-					messageId: ERROR$3,
-					node,
-					filename
-				});
-				else for (const key of Object.keys(wrappedValue[i])) if (![...SHADOW_REQUIRED_PROPERTIES, "inset"].includes(key)) report({
-					messageId: ERROR_INVALID_PROP$2,
-					data: { key: JSON.stringify(key) },
-					node: getObjMember(node.type === "Array" ? node.elements[i].value : node, key),
-					filename
-				});
-			}
-		}
-	}
-};
-var valid_shadow_default = rule$4;
-
-//#endregion
-//#region src/lint/plugin-core/rules/valid-string.ts
-const VALID_STRING = "core/valid-string";
-const ERROR$2 = "ERROR";
-const rule$3 = {
-	meta: {
-		messages: { [ERROR$2]: "Must be a string." },
-		docs: {
-			description: "Require string tokens to follow the Terrazzo extension.",
-			url: docsLink(VALID_STRING)
 		}
-	},
-	defaultOptions: {},
-	create({ tokens, report }) {
-		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "string") continue;
-			validateString(t.originalValue.$value, {
-				node: getObjMember(t.source.node, "$value"),
-				filename: t.source.filename
+		function validateBorder(value, { node, filename }) {
+			if (!value || typeof value !== "object" || !BORDER_REQUIRED_PROPERTIES.every((property) => property in value)) report({
+				messageId: ERROR$1,
+				filename,
+				node
+			});
+			else for (const key of Object.keys(value)) if (!BORDER_REQUIRED_PROPERTIES.includes(key)) report({
+				messageId: ERROR_INVALID_PROP$3,
+				data: { key: JSON.stringify(key) },
+				node: getObjMember(node, key) ?? node,
+				filename
 			});
-			function validateString(value, { node, filename }) {
-				if (typeof value !== "string") report({
-					messageId: ERROR$2,
-					node,
-					filename
-				});
-			}
 		}
 	}
 };
-var valid_string_default = rule$3;
+var valid_border_default = rule$4;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-stroke-style.ts
-const VALID_STROKE_STYLE = "core/valid-stroke-style";
-const ERROR_STR = "ERROR_STR";
-const ERROR_OBJ = "ERROR_OBJ";
-const ERROR_LINE_CAP = "ERROR_LINE_CAP";
-const ERROR_INVALID_PROP$1 = "ERROR_INVALID_PROP";
-const rule$2 = {
+//#region src/lint/plugin-core/rules/valid-color.ts
+const VALID_COLOR = "core/valid-color";
+const ERROR_ALPHA = "ERROR_ALPHA";
+const ERROR_INVALID_COLOR = "ERROR_INVALID_COLOR";
+const ERROR_INVALID_COLOR_SPACE = "ERROR_INVALID_COLOR_SPACE";
+const ERROR_INVALID_COMPONENT_LENGTH = "ERROR_INVALID_COMPONENT_LENGTH";
+const ERROR_INVALID_HEX8 = "ERROR_INVALID_HEX8";
+const ERROR_INVALID_PROP$2 = "ERROR_INVALID_PROP";
+const ERROR_MISSING_COMPONENTS = "ERROR_MISSING_COMPONENTS";
+const ERROR_OBJ_FORMAT = "ERROR_OBJ_FORMAT";
+const ERROR_OUT_OF_RANGE = "ERROR_OUT_OF_RANGE";
+const rule$3 = {
 	meta: {
 		messages: {
-			[ERROR_STR]: `Value most be one of ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(STROKE_STYLE_STRING_VALUES)}.`,
-			[ERROR_OBJ]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
-			[ERROR_LINE_CAP]: `lineCap must be one of ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(STROKE_STYLE_LINE_CAP_VALUES)}.`,
-			[ERROR_INVALID_PROP$1]: "Unknown property: {{ key }}."
+			[ERROR_ALPHA]: `Alpha {{ alpha }} not in range 0 – 1.`,
+			[ERROR_INVALID_COLOR_SPACE]: `Invalid color space: {{ colorSpace }}. Expected ${new Intl.ListFormat("en-us", { type: "disjunction" }).format(Object.keys(COLORSPACE))}`,
+			[ERROR_INVALID_COLOR]: `Could not parse color {{ color }}.`,
+			[ERROR_INVALID_COMPONENT_LENGTH]: "Expected {{ expected }} components, received {{ got }}.",
+			[ERROR_INVALID_HEX8]: `Hex value can’t be semi-transparent.`,
+			[ERROR_INVALID_PROP$2]: `Unknown property {{ key }}.`,
+			[ERROR_MISSING_COMPONENTS]: "Expected components to be array of numbers, received {{ got }}.",
+			[ERROR_OBJ_FORMAT]: "Migrate to the new object format, e.g. \"#ff0000\" → { \"colorSpace\": \"srgb\", \"components\": [1, 0, 0] } }",
+			[ERROR_OUT_OF_RANGE]: `Invalid range for color space {{ colorSpace }}. Expected {{ range }}.`
 		},
 		docs: {
-			description: "Require strokeStyle tokens to follow the format.",
-			url: docsLink(VALID_STROKE_STYLE)
+			description: "Require color tokens to follow the format.",
+			url: docsLink(VALID_COLOR)
 		}
 	},
-	defaultOptions: {},
-	create({ tokens, report }) {
+	defaultOptions: {
+		legacyFormat: false,
+		ignoreRanges: false
+	},
+	create({ tokens, options, report }) {
 		for (const t of Object.values(tokens)) {
 			if (t.aliasOf || !t.originalValue) continue;
 			switch (t.$type) {
-				case "strokeStyle":
-					validateStrokeStyle(t.originalValue.$value, {
+				case "color":
+					validateColor(t.originalValue.$value, {
 						node: getObjMember(t.source.node, "$value"),
 						filename: t.source.filename
 					});
 					break;
 				case "border":
-					if (t.originalValue.$value && typeof t.originalValue.$value === "object") {
-						const $valueNode = getObjMember(t.source.node, "$value");
-						if (t.originalValue.$value.style) validateStrokeStyle(t.originalValue.$value.style, {
-							node: getObjMember($valueNode, "style"),
-							filename: t.source.filename
-						});
+					if (t.originalValue.$value.color && !isAlias(t.originalValue.$value.color)) validateColor(t.originalValue.$value.color, {
+						node: getObjMember(getObjMember(t.source.node, "$value"), "color"),
+						filename: t.source.filename
+					});
+					break;
+				case "gradient": {
+					const $valueNode = getObjMember(t.source.node, "$value");
+					for (let i = 0; i < t.originalValue.$value.length; i++) {
+						const stop = t.originalValue.$value[i];
+						if (!stop.color || isAlias(stop.color)) continue;
+						validateColor(stop.color, {
+							node: getObjMember($valueNode.elements[i].value, "color"),
+							filename: t.source.filename
+						});
+					}
+					break;
+				}
+				case "shadow": {
+					const $value = Array.isArray(t.originalValue.$value) ? t.originalValue.$value : [t.originalValue.$value];
+					const $valueNode = getObjMember(t.source.node, "$value");
+					for (let i = 0; i < $value.length; i++) {
+						const layer = $value[i];
+						if (!layer.color || isAlias(layer.color)) continue;
+						validateColor(layer.color, {
+							node: $valueNode.type === "Object" ? getObjMember($valueNode, "color") : getObjMember($valueNode.elements[i].value, "color"),
+							filename: t.source.filename
+						});
 					}
 					break;
+				}
 			}
-			function validateStrokeStyle(value, { node, filename }) {
-				if (typeof value === "string") {
-					if (!isAlias(value) && !STROKE_STYLE_STRING_VALUES.includes(value)) {
+			function validateColor(value, { node, filename }) {
+				if (!value) report({
+					messageId: ERROR_INVALID_COLOR,
+					data: { color: JSON.stringify(value) },
+					node,
+					filename
+				});
+				else if (typeof value === "object") {
+					for (const key of Object.keys(value)) if (![
+						"colorSpace",
+						"components",
+						"channels",
+						"hex",
+						"alpha"
+					].includes(key)) report({
+						messageId: ERROR_INVALID_PROP$2,
+						data: { key: JSON.stringify(key) },
+						node: getObjMember(node, key) ?? node,
+						filename
+					});
+					const colorSpace = "colorSpace" in value && typeof value.colorSpace === "string" ? value.colorSpace : void 0;
+					const csData = COLORSPACE[colorSpace] || void 0;
+					if (!("colorSpace" in value) || !csData) {
 						report({
-							messageId: ERROR_STR,
-							node,
+							messageId: ERROR_INVALID_COLOR_SPACE,
+							data: { colorSpace },
+							node: getObjMember(node, "colorSpace") ?? node,
 							filename
 						});
 						return;
 					}
-				} else if (value && typeof value === "object") {
-					if (!STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES.every((property) => property in value)) report({
-						messageId: ERROR_OBJ,
-						node,
+					const components = "components" in value ? value.components : void 0;
+					if (Array.isArray(components)) if (csData?.ranges && components?.length === csData.ranges.length) {
+						for (let i = 0; i < components.length; i++) if (!Number.isFinite(components[i]) || components[i] < csData.ranges[i][0] || components[i] > csData.ranges[i][1]) {
+							if (!(colorSpace === "hsl" && components[0] === null) && !(colorSpace === "hwb" && components[0] === null) && !(colorSpace === "lch" && components[2] === null) && !(colorSpace === "oklch" && components[2] === null)) report({
+								messageId: ERROR_OUT_OF_RANGE,
+								data: {
+									colorSpace,
+									range: `[${csData.ranges.map((r) => `${r[0]}–${r[1]}`).join(", ")}]`
+								},
+								node: getObjMember(node, "components") ?? node,
+								filename
+							});
+						}
+					} else report({
+						messageId: ERROR_INVALID_COMPONENT_LENGTH,
+						data: {
+							expected: csData?.ranges.length,
+							got: components?.length ?? 0
+						},
+						node: getObjMember(node, "components") ?? node,
 						filename
 					});
-					if (!Array.isArray(value.dashArray)) report({
-						messageId: ERROR_OBJ,
-						node: getObjMember(node, "dashArray"),
+					else report({
+						messageId: ERROR_MISSING_COMPONENTS,
+						data: { got: JSON.stringify(components) },
+						node: getObjMember(node, "components") ?? node,
 						filename
 					});
-					if (!STROKE_STYLE_LINE_CAP_VALUES.includes(value.lineCap)) report({
-						messageId: ERROR_OBJ,
-						node: getObjMember(node, "lineCap"),
+					const alpha = "alpha" in value ? value.alpha : void 0;
+					if (alpha !== void 0 && (typeof alpha !== "number" || alpha < 0 || alpha > 1)) report({
+						messageId: ERROR_ALPHA,
+						data: { alpha },
+						node: getObjMember(node, "alpha") ?? node,
 						filename
 					});
-					for (const key of Object.keys(value)) if (!["dashArray", "lineCap"].includes(key)) report({
-						messageId: ERROR_INVALID_PROP$1,
-						data: { key: JSON.stringify(key) },
-						node: getObjMember(node, key),
+					const hex = "hex" in value ? value.hex : void 0;
+					if (hex) {
+						let color;
+						try {
+							color = parseColor(hex);
+						} catch {
+							report({
+								messageId: ERROR_INVALID_COLOR,
+								data: { color: hex },
+								node: getObjMember(node, "hex") ?? node,
+								filename
+							});
+							return;
+						}
+						if (color.alpha !== 1) report({
+							messageId: ERROR_INVALID_HEX8,
+							data: { color: hex },
+							node: getObjMember(node, "hex") ?? node,
+							filename
+						});
+					}
+				} else if (typeof value === "string") {
+					if (isAlias(value)) return;
+					if (!options.legacyFormat) report({
+						messageId: ERROR_OBJ_FORMAT,
+						data: { color: JSON.stringify(value) },
+						node,
 						filename
 					});
+					else try {
+						parseColor(value);
+					} catch {
+						report({
+							messageId: ERROR_INVALID_COLOR,
+							data: { color: JSON.stringify(value) },
+							node,
+							filename
+						});
+					}
 				} else report({
-					messageId: ERROR_OBJ,
+					messageId: ERROR_INVALID_COLOR,
 					node,
 					filename
 				});
@@ -1920,92 +1708,319 @@ const rule$2 = {
 		}
 	}
 };
-var valid_stroke_style_default = rule$2;
+var valid_color_default = rule$3;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-transition.ts
-const VALID_TRANSITION = "core/valid-transition";
-const ERROR$1 = "ERROR";
-const ERROR_INVALID_PROP = "ERROR_INVALID_PROP";
-const rule$1 = {
+//#region src/lint/plugin-core/rules/valid-cubic-bezier.ts
+const VALID_CUBIC_BEZIER = "core/valid-cubic-bezier";
+const ERROR = "ERROR";
+const ERROR_X = "ERROR_X";
+const ERROR_Y = "ERROR_Y";
+const rule$2 = {
 	meta: {
 		messages: {
-			[ERROR$1]: `Missing required properties: ${new Intl.ListFormat("en-us", { type: "conjunction" }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
-			[ERROR_INVALID_PROP]: "Unknown property: {{ key }}."
+			[ERROR]: "Expected [number, number, number, number].",
+			[ERROR_X]: "x values must be between 0-1.",
+			[ERROR_Y]: "y values must be a valid number."
 		},
 		docs: {
-			description: "Require transition tokens to follow the format.",
-			url: docsLink(VALID_TRANSITION)
+			description: "Require cubicBezier tokens to follow the format.",
+			url: docsLink(VALID_CUBIC_BEZIER)
 		}
 	},
 	defaultOptions: {},
 	create({ tokens, report }) {
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "transition") continue;
-			validateTransition(t.originalValue.$value, {
-				node: getObjMember(t.source.node, "$value"),
-				filename: t.source.filename
-			});
-		}
-		function validateTransition(value, { node, filename }) {
-			if (!value || typeof value !== "object" || !TRANSITION_REQUIRED_PROPERTIES.every((property) => property in value)) report({
-				messageId: ERROR$1,
-				node,
-				filename
-			});
-			else for (const key of Object.keys(value)) if (!TRANSITION_REQUIRED_PROPERTIES.includes(key)) report({
-				messageId: ERROR_INVALID_PROP,
-				data: { key: JSON.stringify(key) },
-				node: getObjMember(node, key),
-				filename
-			});
+			if (t.aliasOf || !t.originalValue) continue;
+			switch (t.$type) {
+				case "cubicBezier":
+					validateCubicBezier(t.originalValue.$value, {
+						node: getObjMember(t.source.node, "$value"),
+						filename: t.source.filename
+					});
+					break;
+				case "transition": if (typeof t.originalValue.$value === "object" && t.originalValue.$value.timingFunction && !isAlias(t.originalValue.$value.timingFunction)) {
+					const $valueNode = getObjMember(t.source.node, "$value");
+					validateCubicBezier(t.originalValue.$value.timingFunction, {
+						node: getObjMember($valueNode, "timingFunction"),
+						filename: t.source.filename
+					});
+				}
+			}
+			function validateCubicBezier(value, { node, filename }) {
+				if (Array.isArray(value) && value.length === 4) {
+					for (const pos of [0, 2]) {
+						if (isAlias(value[pos]) || isPure$ref(value[pos])) continue;
+						if (!(value[pos] >= 0 && value[pos] <= 1)) report({
+							messageId: ERROR_X,
+							node: node.elements[pos],
+							filename
+						});
+					}
+					for (const pos of [1, 3]) {
+						if (isAlias(value[pos]) || isPure$ref(value[pos])) continue;
+						if (typeof value[pos] !== "number") report({
+							messageId: ERROR_Y,
+							node: node.elements[pos],
+							filename
+						});
+					}
+				} else report({
+					messageId: ERROR,
+					node,
+					filename
+				});
+			}
 		}
 	}
 };
-var valid_transition_default = rule$1;
+var valid_cubic_bezier_default = rule$2;
 
 //#endregion
-//#region src/lint/plugin-core/rules/valid-typography.ts
-const VALID_TYPOGRAPHY = "core/valid-typography";
-const ERROR = "ERROR";
-const ERROR_MISSING = "ERROR_MISSING";
-const rule = {
+//#region src/lint/plugin-core/rules/valid-dimension.ts
+const VALID_DIMENSION = "core/valid-dimension";
+const ERROR_FORMAT$1 = "ERROR_FORMAT";
+const ERROR_INVALID_PROP$1 = "ERROR_INVALID_PROP";
+const ERROR_LEGACY$1 = "ERROR_LEGACY";
+const ERROR_UNIT$1 = "ERROR_UNIT";
+const ERROR_VALUE$1 = "ERROR_VALUE";
+const rule$1 = {
 	meta: {
 		messages: {
-			[ERROR]: `Expected object, received {{ value }}.`,
-			[ERROR_MISSING]: `Missing required property "{{ property }}".`
+			[ERROR_FORMAT$1]: "Invalid dimension: {{ value }}. Expected object with \"value\" and \"unit\".",
+			[ERROR_LEGACY$1]: "Migrate to the new object format: { \"value\": 10, \"unit\": \"px\" }.",
+			[ERROR_UNIT$1]: "Unit {{ unit }} not allowed. Expected {{ allowed }}.",
+			[ERROR_INVALID_PROP$1]: "Unknown property {{ key }}.",
+			[ERROR_VALUE$1]: "Expected number, received {{ value }}."
 		},
 		docs: {
-			description: "Require typography tokens to follow the format.",
-			url: docsLink(VALID_TYPOGRAPHY)
+			description: "Require dimension tokens to follow the format",
+			url: docsLink(VALID_DIMENSION)
 		}
 	},
-	defaultOptions: { requiredProperties: [
-		"fontFamily",
-		"fontSize",
-		"fontWeight",
-		"letterSpacing",
-		"lineHeight"
-	] },
+	defaultOptions: {
+		legacyFormat: false,
+		allowedUnits: [
+			"px",
+			"em",
+			"rem"
+		]
+	},
 	create({ tokens, options, report }) {
-		const isIgnored = options.ignore ? wcmatch(options.ignore) : () => false;
 		for (const t of Object.values(tokens)) {
-			if (t.aliasOf || !t.originalValue || t.$type !== "typography" || isIgnored(t.id)) continue;
-			validateTypography(t.originalValue.$value, {
-				node: getObjMember(t.source.node, "$value"),
-				filename: t.source.filename
-			});
-			function validateTypography(value, { node, filename }) {
+			if (t.aliasOf || !t.originalValue) continue;
+			switch (t.$type) {
+				case "dimension":
+					validateDimension(t.originalValue.$value, {
+						node: getObjMember(t.source.node, "$value"),
+						filename: t.source.filename
+					});
+					break;
+				case "strokeStyle":
+					if (typeof t.originalValue.$value === "object" && Array.isArray(t.originalValue.$value.dashArray)) {
+						const dashArray = getObjMember(getObjMember(t.source.node, "$value"), "dashArray");
+						for (let i = 0; i < t.originalValue.$value.dashArray.length; i++) {
+							if (isAlias(t.originalValue.$value.dashArray[i])) continue;
+							validateDimension(t.originalValue.$value.dashArray[i], {
+								node: dashArray.elements[i].value,
+								filename: t.source.filename
+							});
+						}
+					}
+					break;
+				case "border": {
+					const $valueNode = getObjMember(t.source.node, "$value");
+					if (typeof t.originalValue.$value === "object") {
+						if (t.originalValue.$value.width && !isAlias(t.originalValue.$value.width)) validateDimension(t.originalValue.$value.width, {
+							node: getObjMember($valueNode, "width"),
+							filename: t.source.filename
+						});
+						if (typeof t.originalValue.$value.style === "object" && Array.isArray(t.originalValue.$value.style.dashArray)) {
+							const dashArray = getObjMember(getObjMember($valueNode, "style"), "dashArray");
+							for (let i = 0; i < t.originalValue.$value.style.dashArray.length; i++) {
+								if (isAlias(t.originalValue.$value.style.dashArray[i])) continue;
+								validateDimension(t.originalValue.$value.style.dashArray[i], {
+									node: dashArray.elements[i].value,
+									filename: t.source.filename
+								});
+							}
+						}
+					}
+					break;
+				}
+				case "shadow":
+					if (t.originalValue.$value && typeof t.originalValue.$value === "object") {
+						const $valueNode = getObjMember(t.source.node, "$value");
+						const valueArray = Array.isArray(t.originalValue.$value) ? t.originalValue.$value : [t.originalValue.$value];
+						for (let i = 0; i < valueArray.length; i++) {
+							const node = $valueNode.type === "Array" ? $valueNode.elements[i].value : $valueNode;
+							for (const property of [
+								"offsetX",
+								"offsetY",
+								"blur",
+								"spread"
+							]) {
+								if (isAlias(valueArray[i][property])) continue;
+								validateDimension(valueArray[i][property], {
+									node: getObjMember(node, property),
+									filename: t.source.filename
+								});
+							}
+						}
+					}
+					break;
+				case "typography": {
+					const $valueNode = getObjMember(t.source.node, "$value");
+					if (typeof t.originalValue.$value === "object") {
+						for (const property of [
+							"fontSize",
+							"lineHeight",
+							"letterSpacing"
+						]) if (property in t.originalValue.$value) {
+							if (isAlias(t.originalValue.$value[property]) || property === "lineHeight" && typeof t.originalValue.$value[property] === "number") continue;
+							validateDimension(t.originalValue.$value[property], {
+								node: getObjMember($valueNode, property),
+								filename: t.source.filename
+							});
+						}
+					}
+					break;
+				}
+			}
+			function validateDimension(value, { node, filename }) {
 				if (value && typeof value === "object") {
-					for (const property of options.requiredProperties) if (!(property in value)) report({
-						messageId: ERROR_MISSING,
-						data: { property },
-						node,
+					for (const key of Object.keys(value)) if (!["value", "unit"].includes(key)) report({
+						messageId: ERROR_INVALID_PROP$1,
+						data: { key: JSON.stringify(key) },
+						node: getObjMember(node, key) ?? node,
 						filename
 					});
-				} else report({
-					messageId: ERROR,
-					data: { value: JSON.stringify(value) },
+					const { unit, value: numValue } = value;
+					if (!("value" in value || "unit" in value)) {
+						report({
+							messageId: ERROR_FORMAT$1,
+							data: { value },
+							node,
+							filename
+						});
+						return;
+					}
+					if (!options.allowedUnits.includes(unit)) report({
+						messageId: ERROR_UNIT$1,
+						data: {
+							unit,
+							allowed: new Intl.ListFormat("en-us", { type: "disjunction" }).format(options.allowedUnits)
+						},
+						node: getObjMember(node, "unit") ?? node,
+						filename
+					});
+					if (!Number.isFinite(numValue)) report({
+						messageId: ERROR_VALUE$1,
+						data: { value },
+						node: getObjMember(node, "value") ?? node,
+						filename
+					});
+				} else if (typeof value === "string" && !options.legacyFormat) report({
+					messageId: ERROR_LEGACY$1,
+					node,
+					filename
+				});
+				else report({
+					messageId: ERROR_FORMAT$1,
+					data: { value },
+					node,
+					filename
+				});
+			}
+		}
+	}
+};
+var valid_dimension_default = rule$1;
+
+//#endregion
+//#region src/lint/plugin-core/rules/valid-duration.ts
+const VALID_DURATION = "core/valid-duration";
+const ERROR_FORMAT = "ERROR_FORMAT";
+const ERROR_INVALID_PROP = "ERROR_INVALID_PROP";
+const ERROR_LEGACY = "ERROR_LEGACY";
+const ERROR_UNIT = "ERROR_UNIT";
+const ERROR_VALUE = "ERROR_VALUE";
+const rule = {
+	meta: {
+		messages: {
+			[ERROR_FORMAT]: "Migrate to the new object format: { \"value\": 2, \"unit\": \"ms\" }.",
+			[ERROR_LEGACY]: "Migrate to the new object format: { \"value\": 10, \"unit\": \"px\" }.",
+			[ERROR_INVALID_PROP]: "Unknown property: {{ key }}.",
+			[ERROR_UNIT]: "Unknown unit {{ unit }}. Expected \"ms\" or \"s\".",
+			[ERROR_VALUE]: "Expected number, received {{ value }}."
+		},
+		docs: {
+			description: "Require duration tokens to follow the format",
+			url: docsLink(VALID_DURATION)
+		}
+	},
+	defaultOptions: {
+		legacyFormat: false,
+		unknownUnits: false
+	},
+	create({ tokens, options, report }) {
+		for (const t of Object.values(tokens)) {
+			if (t.aliasOf || !t.originalValue) continue;
+			switch (t.$type) {
+				case "duration":
+					validateDuration(t.originalValue.$value, {
+						node: getObjMember(t.source.node, "$value"),
+						filename: t.source.filename
+					});
+					break;
+				case "transition":
+					if (typeof t.originalValue.$value === "object") {
+						const $valueNode = getObjMember(t.source.node, "$value");
+						for (const property of ["duration", "delay"]) if (t.originalValue.$value[property] && !isAlias(t.originalValue.$value[property])) validateDuration(t.originalValue.$value[property], {
+							node: getObjMember($valueNode, property),
+							filename: t.source.filename
+						});
+					}
+					break;
+			}
+			function validateDuration(value, { node, filename }) {
+				if (value && typeof value === "object") {
+					for (const key of Object.keys(value)) if (!["value", "unit"].includes(key)) report({
+						messageId: ERROR_INVALID_PROP,
+						data: { key: JSON.stringify(key) },
+						node: getObjMember(node, key) ?? node,
+						filename
+					});
+					const { unit, value: numValue } = value;
+					if (!("value" in value || "unit" in value)) {
+						report({
+							messageId: ERROR_FORMAT,
+							data: { value },
+							node,
+							filename
+						});
+						return;
+					}
+					if (!options.unknownUnits && !["ms", "s"].includes(unit)) report({
+						messageId: ERROR_UNIT,
+						data: { unit },
+						node: getObjMember(node, "unit") ?? node,
+						filename
+					});
+					if (!Number.isFinite(numValue)) report({
+						messageId: ERROR_VALUE,
+						data: { value },
+						node: getObjMember(node, "value") ?? node,
+						filename
+					});
+				} else if (typeof value === "string" && !options.legacyFormat) report({
+					messageId: ERROR_FORMAT,
+					node,
+					filename
+				});
+				else report({
+					messageId: ERROR_FORMAT,
+					data: { value },
 					node,
 					filename
 				});
@@ -2013,7 +2028,7 @@ const rule = {
 		}
 	}
 };
-var valid_typography_default = rule;
+var valid_duration_default = rule;
 
 //#endregion
 //#region src/lint/plugin-core/index.ts
@@ -2150,6 +2165,7 @@ function normalizeTokens({ rawConfig, config, logger, cwd }) {
 			});
 		}
 	}
+	config.alphabetize = rawConfig.alphabetize ?? true;
 }
 /** Normalize config.outDir */
 function normalizeOutDir({ config, cwd, logger }) {
@@ -2423,1179 +2439,1207 @@ function filterResolverPaths(path) {
 	}
 	return path;
 }
-/**
-* Make a deterministic string from an object
-*/
-function makeInputKey(input) {
-	return JSON.stringify(Object.fromEntries(Object.entries(input).sort((a, b) => a[0].localeCompare(b[0], "en-us", { numeric: true }))));
+/** Make a deterministic string from an object */
+function getPermutationID(input) {
+	const keys = Object.keys(input).sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
+	return JSON.stringify(Object.fromEntries(keys.map((k) => [k, input[k]])));
 }
 
 //#endregion
-//#region src/resolver/validate.ts
+//#region src/parse/assert.ts
+function assert(value, logger, entry) {
+	if (!value) logger.error(entry);
+}
+function assertStringNode(value, logger, entry) {
+	assert(value?.type === "String", logger, entry);
+}
+function assertObjectNode(value, logger, entry) {
+	assert(value?.type === "Object", logger, entry);
+}
+
+//#endregion
+//#region src/parse/normalize.ts
 /**
-* Determine whether this is likely a resolver
-* We use terms the word “likely” because this occurs before validation. Since
-* we may be dealing with a doc _intended_ to be a resolver, but may be lacking
-* some critical information, how can we determine intent? There’s a bit of
-* guesswork here, but we try and find a reasonable edge case where we sniff out
-* invalid DTCG syntax that a resolver doc would have.
+* Normalize token value.
+* The reason for the “any” typing is this aligns various user-provided inputs to the type
 */
-function isLikelyResolver(doc) {
-	if (doc.body.type !== "Object") return false;
-	for (const member of doc.body.members) {
-		if (member.name.type !== "String") continue;
-		switch (member.name.value) {
-			case "name":
-			case "description":
-			case "version":
-				if (member.value.type === "String") return true;
-				break;
-			case "sets":
-			case "modifiers":
-				if (member.value.type !== "Object") continue;
-				if (getObjMember(member.value, "description")?.type === "String") return true;
-				if (member.name.value === "sets" && getObjMember(member.value, "sources")?.type === "Array") return true;
-				else if (member.name.value === "modifiers") {
-					const contexts = getObjMember(member.value, "contexts");
-					if (contexts?.type === "Object" && contexts.members.some((m) => m.value.type === "Array")) return true;
-				}
-				break;
-			case "resolutionOrder":
-				if (member.value.type === "Array") return true;
-				break;
-		}
-	}
-	return false;
-}
-const MESSAGE_EXPECTED = {
-	STRING: "Expected string.",
-	OBJECT: "Expected object.",
-	ARRAY: "Expected array."
-};
-/**
-* Validate a resolver document.
-* There’s a ton of boilerplate here, only to surface detailed code frames. Is there a better abstraction?
-*/
-function validateResolver(node, { logger, src }) {
+function normalize(token, { logger, src }) {
 	const entry = {
 		group: "parser",
-		label: "resolver",
+		label: "init",
 		src
 	};
-	if (node.body.type !== "Object") logger.error({
-		...entry,
-		message: MESSAGE_EXPECTED.OBJECT,
-		node
-	});
-	const errors = [];
-	let hasVersion = false;
-	let hasResolutionOrder = false;
-	for (const member of node.body.members) {
-		if (member.name.type !== "String") continue;
-		switch (member.name.value) {
-			case "name":
-			case "description":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING
-				});
-				break;
-			case "version":
-				hasVersion = true;
-				if (member.value.type !== "String" || member.value.value !== "2025.10") errors.push({
-					...entry,
-					message: `Expected "version" to be "2025.10".`,
-					node: member.value
-				});
-				break;
-			case "sets":
-			case "modifiers":
-				if (member.value.type !== "Object") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.OBJECT,
-					node: member.value
-				});
-				else for (const item of member.value.members) if (item.value.type !== "Object") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.OBJECT,
-					node: item.value
-				});
-				else {
-					const validator = member.name.value === "sets" ? validateSet : validateModifier;
-					errors.push(...validator(item.value, false, {
-						logger,
-						src
-					}));
+	function normalizeFontFamily(value) {
+		return typeof value === "string" ? [value] : value;
+	}
+	function normalizeFontWeight(value) {
+		return typeof value === "string" && FONT_WEIGHTS[value] || value;
+	}
+	function normalizeColor(value, node) {
+		if (typeof value === "string" && !isAlias(value)) {
+			logger.warn({
+				...entry,
+				node,
+				message: `${token.id}: string colors will be deprecated in a future version. Please update to object notation`
+			});
+			try {
+				return parseColor(value);
+			} catch {
+				return {
+					colorSpace: "srgb",
+					components: [
+						0,
+						0,
+						0
+					],
+					alpha: 1
+				};
+			}
+		} else if (value && typeof value === "object") {
+			if (value.alpha === void 0) value.alpha = 1;
+		}
+		return value;
+	}
+	switch (token.$type) {
+		case "color":
+			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeColor(token.mode[mode].$value, token.mode[mode].source.node);
+			token.$value = token.mode["."].$value;
+			break;
+		case "fontFamily":
+			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeFontFamily(token.mode[mode].$value);
+			token.$value = token.mode["."].$value;
+			break;
+		case "fontWeight":
+			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeFontWeight(token.mode[mode].$value);
+			token.$value = token.mode["."].$value;
+			break;
+		case "border":
+			for (const mode of Object.keys(token.mode)) {
+				const border = token.mode[mode].$value;
+				if (!border || typeof border !== "object") continue;
+				if (border.color) border.color = normalizeColor(border.color, getObjMember(token.mode[mode].source.node, "color"));
+			}
+			token.$value = token.mode["."].$value;
+			break;
+		case "shadow":
+			for (const mode of Object.keys(token.mode)) {
+				if (!Array.isArray(token.mode[mode].$value)) token.mode[mode].$value = [token.mode[mode].$value];
+				const $value = token.mode[mode].$value;
+				for (let i = 0; i < $value.length; i++) {
+					const shadow = $value[i];
+					if (!shadow || typeof shadow !== "object") continue;
+					const shadowNode = token.mode[mode].source.node.type === "Array" ? token.mode[mode].source.node.elements[i].value : token.mode[mode].source.node;
+					if (shadow.color) shadow.color = normalizeColor(shadow.color, getObjMember(shadowNode, "color"));
+					if (!("inset" in shadow)) shadow.inset = false;
 				}
-				break;
-			case "resolutionOrder":
-				hasResolutionOrder = true;
-				if (member.value.type !== "Array") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.ARRAY,
-					node: member.value
-				});
-				else if (member.value.elements.length === 0) errors.push({
-					...entry,
-					message: `"resolutionOrder" can’t be empty array.`,
-					node: member.value
-				});
-				else for (const item of member.value.elements) if (item.value.type !== "Object") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.OBJECT,
-					node: item.value
-				});
-				else {
-					const itemMembers = getObjMembers(item.value);
-					if (itemMembers.$ref?.type === "String") continue;
-					if (itemMembers.type?.type === "String") if (itemMembers.type.value === "set") validateSet(item.value, true, {
-						logger,
-						src
-					});
-					else if (itemMembers.type.value === "modifier") validateModifier(item.value, true, {
-						logger,
-						src
-					});
-					else errors.push({
-						...entry,
-						message: `Unknown type ${JSON.stringify(itemMembers.type.value)}`,
-						node: itemMembers.type
-					});
-					if (itemMembers.sources?.type === "Array") validateSet(item.value, true, {
-						logger,
-						src
-					});
-					else if (itemMembers.contexts?.type === "Object") validateModifier(item.value, true, {
-						logger,
-						src
-					});
-					else if (itemMembers.name?.type === "String" || itemMembers.description?.type === "String") validateSet(item.value, true, {
-						logger,
-						src
-					});
+			}
+			token.$value = token.mode["."].$value;
+			break;
+		case "gradient":
+			for (const mode of Object.keys(token.mode)) {
+				if (!Array.isArray(token.mode[mode].$value)) continue;
+				const $value = token.mode[mode].$value;
+				for (let i = 0; i < $value.length; i++) {
+					const stop = $value[i];
+					if (!stop || typeof stop !== "object") continue;
+					const stopNode = token.mode[mode].source.node?.elements?.[i]?.value;
+					if (stop.color) stop.color = normalizeColor(stop.color, getObjMember(stopNode, "color"));
 				}
-				break;
-			case "$defs":
-			case "$extensions":
-				if (member.value.type !== "Object") errors.push({
-					...entry,
-					message: `Expected object`,
-					node: member.value
-				});
-				break;
-			case "$schema":
-			case "$ref":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: `Expected string`,
-					node: member.value
-				});
-				break;
-			default:
-				errors.push({
-					...entry,
-					message: `Unknown key ${JSON.stringify(member.name.value)}`,
-					node: member.name,
-					src
-				});
-				break;
-		}
+			}
+			token.$value = token.mode["."].$value;
+			break;
+		case "typography":
+			for (const mode of Object.keys(token.mode)) {
+				const $value = token.mode[mode].$value;
+				if (typeof $value !== "object") return;
+				for (const [k, v] of Object.entries($value)) switch (k) {
+					case "fontFamily":
+						$value[k] = normalizeFontFamily(v);
+						break;
+					case "fontWeight":
+						$value[k] = normalizeFontWeight(v);
+						break;
+				}
+			}
+			token.$value = token.mode["."].$value;
+			break;
 	}
-	if (!hasVersion) errors.push({
-		...entry,
-		message: `Missing "version".`,
-		node,
-		src
-	});
-	if (!hasResolutionOrder) errors.push({
-		...entry,
-		message: `Missing "resolutionOrder".`,
-		node,
-		src
-	});
-	if (errors.length) logger.error(...errors);
 }
-function validateSet(node, isInline = false, { src }) {
-	const entry = {
-		group: "parser",
-		label: "resolver",
-		src
-	};
-	const errors = [];
-	let hasName = !isInline;
-	let hasType = !isInline;
-	let hasSources = false;
-	for (const member of node.members) {
-		if (member.name.type !== "String") continue;
-		switch (member.name.value) {
-			case "name":
-				hasName = true;
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				break;
-			case "description":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				break;
-			case "type":
-				hasType = true;
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				else if (member.value.value !== "set") errors.push({
-					...entry,
-					message: "\"type\" must be \"set\"."
-				});
-				break;
-			case "sources":
-				hasSources = true;
-				if (member.value.type !== "Array") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.ARRAY,
-					node: member.value
-				});
-				else if (member.value.elements.length === 0) errors.push({
-					...entry,
-					message: `"sources" can’t be empty array.`,
-					node: member.value
-				});
-				break;
-			case "$defs":
-			case "$extensions":
-				if (member.value.type !== "Object") errors.push({
-					...entry,
-					message: `Expected object`,
-					node: member.value
-				});
-				break;
-			case "$ref":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: `Expected string`,
-					node: member.value
-				});
-				break;
-			default:
-				errors.push({
-					...entry,
-					message: `Unknown key ${JSON.stringify(member.name.value)}`,
-					node: member.name
-				});
-				break;
+
+//#endregion
+//#region src/parse/token.ts
+/** Convert valid DTCG alias to $ref */
+function aliasToGroupRef(alias) {
+	const id = parseAlias(alias);
+	if (id === alias) return;
+	return { $ref: `#/${id.replace(/~/g, "~0").replace(/\//g, "~1").replace(/\./g, "/")}` };
+}
+/** Convert valid DTCG alias to $ref */
+function aliasToTokenRef(alias, mode) {
+	const id = parseAlias(alias);
+	if (id === alias) return;
+	return { $ref: `#/${id.replace(/~/g, "~0").replace(/\//g, "~1").replace(/\./g, "/")}${mode && mode !== "." ? `/$extensions/mode/${mode}` : ""}/$value` };
+}
+/** Generate a TokenNormalized from a Momoa node */
+function tokenFromNode(node, { groups, path, source, ignore }) {
+	if (!(node.type === "Object" && !!getObjMember(node, "$value") && !path.includes("$extensions"))) return;
+	const jsonID = encodeFragment(path);
+	const id = path.join(".").replace(/\.\$root$/, "");
+	const originalToken = momoa.evaluate(node);
+	const group = groups[encodeFragment(path.slice(0, -1))];
+	if (group?.tokens && !group.tokens.includes(id)) group.tokens.push(id);
+	const nodeSource = {
+		filename: source.filename.href,
+		node
+	};
+	const token = {
+		id,
+		$type: originalToken.$type || group.$type,
+		$description: originalToken.$description || void 0,
+		$deprecated: originalToken.$deprecated ?? group.$deprecated ?? void 0,
+		$value: originalToken.$value,
+		$extensions: originalToken.$extensions || void 0,
+		$extends: originalToken.$extends || void 0,
+		aliasChain: void 0,
+		aliasedBy: void 0,
+		aliasOf: void 0,
+		partialAliasOf: void 0,
+		dependencies: void 0,
+		group,
+		originalValue: void 0,
+		source: nodeSource,
+		jsonID,
+		mode: { ".": {
+			$value: originalToken.$value,
+			aliasOf: void 0,
+			aliasChain: void 0,
+			partialAliasOf: void 0,
+			aliasedBy: void 0,
+			originalValue: void 0,
+			dependencies: void 0,
+			source: {
+				...nodeSource,
+				node: getObjMember(nodeSource.node, "$value") ?? nodeSource.node
+			}
+		} }
+	};
+	if (ignore?.deprecated && token.$deprecated || ignore?.tokens && wcmatch(ignore.tokens)(token.id)) return;
+	const $extensions = getObjMember(node, "$extensions");
+	if ($extensions) {
+		const modeNode = getObjMember($extensions, "mode");
+		for (const mode of Object.keys(token.$extensions.mode ?? {})) {
+			const modeValue = token.$extensions.mode[mode];
+			token.mode[mode] = {
+				$value: modeValue,
+				aliasOf: void 0,
+				aliasChain: void 0,
+				partialAliasOf: void 0,
+				aliasedBy: void 0,
+				originalValue: void 0,
+				dependencies: void 0,
+				source: {
+					...nodeSource,
+					node: getObjMember(modeNode, mode)
+				}
+			};
 		}
 	}
-	if (!hasName) errors.push({
-		...entry,
-		message: `Missing "name".`,
-		node
-	});
-	if (!hasType) errors.push({
-		...entry,
-		message: `"type": "set" missing.`,
-		node
-	});
-	if (!hasSources) errors.push({
-		...entry,
-		message: `Missing "sources".`,
-		node
-	});
-	return errors;
+	return token;
 }
-function validateModifier(node, isInline = false, { src }) {
-	const errors = [];
-	const entry = {
-		group: "parser",
-		label: "resolver",
-		src
+/** Generate originalValue and source from node */
+function tokenRawValuesFromNode(node, { filename, path }) {
+	if (!(node.type === "Object" && getObjMember(node, "$value") && !path.includes("$extensions"))) return;
+	const rawValues = {
+		jsonID: encodeFragment(path),
+		originalValue: momoa.evaluate(node),
+		source: {
+			loc: filename,
+			filename,
+			node
+		},
+		mode: {}
 	};
-	let hasName = !isInline;
-	let hasType = !isInline;
-	let hasContexts = false;
-	for (const member of node.members) {
-		if (member.name.type !== "String") continue;
-		switch (member.name.value) {
-			case "name":
-				hasName = true;
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				break;
-			case "description":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				break;
-			case "type":
-				hasType = true;
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.STRING,
-					node: member.value
-				});
-				else if (member.value.value !== "modifier") errors.push({
-					...entry,
-					message: "\"type\" must be \"modifier\"."
-				});
-				break;
-			case "contexts":
-				hasContexts = true;
-				if (member.value.type !== "Object") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.OBJECT,
-					node: member.value
-				});
-				else if (member.value.members.length === 0) errors.push({
-					...entry,
-					message: `"contexts" can’t be empty object.`,
-					node: member.value
-				});
-				else for (const context of member.value.members) if (context.value.type !== "Array") errors.push({
-					...entry,
-					message: MESSAGE_EXPECTED.ARRAY,
-					node: context.value
-				});
-				break;
-			case "default":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: `Expected string`,
-					node: member.value
-				});
-				else {
-					const contexts = getObjMember(node, "contexts");
-					if (!contexts || !getObjMember(contexts, member.value.value)) errors.push({
-						...entry,
-						message: "Invalid default context",
-						node: member.value
-					});
+	rawValues.mode["."] = {
+		originalValue: rawValues.originalValue.$value,
+		source: {
+			...rawValues.source,
+			node: getObjMember(node, "$value")
+		}
+	};
+	const $extensions = getObjMember(node, "$extensions");
+	if ($extensions) {
+		const modes = getObjMember($extensions, "mode");
+		if (modes) for (const modeMember of modes.members) {
+			const mode = modeMember.name.value;
+			rawValues.mode[mode] = {
+				originalValue: momoa.evaluate(modeMember.value),
+				source: {
+					loc: filename,
+					filename,
+					node: modeMember.value
+				}
+			};
+		}
+	}
+	return rawValues;
+}
+/** Arbitrary keys that should be associated with a token group */
+const GROUP_PROPERTIES = [
+	"$deprecated",
+	"$description",
+	"$extensions",
+	"$type"
+];
+/**
+* Generate a group from a node.
+* This method mutates the groups index as it goes because of group inheritance.
+* As it encounters new groups it may have to update other groups.
+*/
+function groupFromNode(node, { path, groups }) {
+	const id = path.join(".");
+	const jsonID = encodeFragment(path);
+	if (!groups[jsonID]) groups[jsonID] = {
+		id,
+		$deprecated: void 0,
+		$description: void 0,
+		$extensions: void 0,
+		$type: void 0,
+		tokens: []
+	};
+	const groupIDs = Object.keys(groups);
+	groupIDs.sort();
+	for (const groupID of groupIDs) if (jsonID.startsWith(groupID) && groupID !== jsonID) {
+		groups[jsonID].$deprecated = groups[groupID]?.$deprecated ?? groups[jsonID].$deprecated;
+		groups[jsonID].$description = groups[groupID]?.$description ?? groups[jsonID].$description;
+		groups[jsonID].$type = groups[groupID]?.$type ?? groups[jsonID].$type;
+	}
+	for (const m of node.members) {
+		if (m.name.type !== "String" || !GROUP_PROPERTIES.includes(m.name.value)) continue;
+		groups[jsonID][m.name.value] = momoa.evaluate(m.value);
+	}
+	return groups[jsonID];
+}
+/**
+* Link and reverse-link tokens in one pass.
+*/
+function graphAliases(refMap, { tokens, logger, sources }) {
+	const getTokenRef = (ref) => ref.replace(/\/(\$value|\$extensions)\/?.*/, "");
+	for (const [jsonID, { refChain }] of Object.entries(refMap)) {
+		if (!refChain.length) continue;
+		const mode = jsonID.match(/\/\$extensions\/mode\/([^/]+)/)?.[1] || ".";
+		const rootRef = getTokenRef(jsonID);
+		const modeValue = tokens[rootRef]?.mode[mode];
+		if (!modeValue) continue;
+		if (!modeValue.dependencies) modeValue.dependencies = [];
+		modeValue.dependencies.push(...refChain.filter((r) => !modeValue.dependencies.includes(r)));
+		modeValue.dependencies.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
+		if (jsonID.endsWith("/$value") || tokens[jsonID]) {
+			modeValue.aliasOf = refToTokenID(refChain.at(-1));
+			modeValue.aliasChain = [...refChain.map(refToTokenID)];
+		}
+		const partial = jsonID.replace(/.*\/\$value\/?/, "").split("/").filter(Boolean);
+		if (partial.length && modeValue.$value && typeof modeValue.$value === "object") {
+			let node = modeValue.$value;
+			let sourceNode = modeValue.source.node;
+			if (!modeValue.partialAliasOf) modeValue.partialAliasOf = Array.isArray(modeValue.$value) || tokens[rootRef]?.$type === "shadow" ? [] : {};
+			let partialAliasOf = modeValue.partialAliasOf;
+			if (tokens[rootRef]?.$type === "shadow" && !Array.isArray(node)) {
+				if (Array.isArray(modeValue.partialAliasOf) && !modeValue.partialAliasOf.length) modeValue.partialAliasOf.push({});
+				partialAliasOf = modeValue.partialAliasOf[0];
+			}
+			for (let i = 0; i < partial.length; i++) {
+				let key = partial[i];
+				if (String(Number(key)) === key) key = Number(key);
+				if (key in node && typeof node[key] !== "undefined") {
+					node = node[key];
+					if (sourceNode.type === "Object") sourceNode = getObjMember(sourceNode, key) ?? sourceNode;
+					else if (sourceNode.type === "Array") sourceNode = sourceNode.elements[key]?.value ?? sourceNode;
+				}
+				if (i === partial.length - 1) {
+					const aliasedID = getTokenRef(refChain[0]);
+					if (!(aliasedID in tokens)) {
+						logger.error({
+							group: "parser",
+							label: "init",
+							message: `Invalid alias: ${aliasedID}`,
+							node: sourceNode,
+							src: sources[tokens[rootRef].source.filename]?.src
+						});
+						break;
+					}
+					partialAliasOf[key] = refToTokenID(aliasedID);
+				}
+				if (!(key in partialAliasOf)) partialAliasOf[key] = Array.isArray(node) ? [] : {};
+				partialAliasOf = partialAliasOf[key];
+			}
+		}
+		const aliasedByRefs = [jsonID, ...refChain].reverse();
+		for (let i = 0; i < aliasedByRefs.length; i++) {
+			const baseRef = getTokenRef(aliasedByRefs[i]);
+			const baseToken = tokens[baseRef]?.mode[mode] || tokens[baseRef];
+			if (!baseToken) continue;
+			const upstream = aliasedByRefs.slice(i + 1);
+			if (!upstream.length) break;
+			if (!baseToken.aliasedBy) baseToken.aliasedBy = [];
+			for (let j = 0; j < upstream.length; j++) {
+				const downstream = refToTokenID(upstream[j]);
+				if (!baseToken.aliasedBy.includes(downstream)) {
+					baseToken.aliasedBy.push(downstream);
+					if (mode === ".") tokens[baseRef].aliasedBy = baseToken.aliasedBy;
 				}
-				break;
-			case "$defs":
-			case "$extensions":
-				if (member.value.type !== "Object") errors.push({
-					...entry,
-					message: `Expected object`,
-					node: member.value
-				});
-				break;
-			case "$ref":
-				if (member.value.type !== "String") errors.push({
-					...entry,
-					message: `Expected string`,
-					node: member.value
-				});
-				break;
-			default:
-				errors.push({
-					...entry,
-					message: `Unknown key ${JSON.stringify(member.name.value)}`,
-					node: member.name
-				});
-				break;
+			}
+			baseToken.aliasedBy.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
+		}
+		if (mode === ".") {
+			tokens[rootRef].aliasChain = modeValue.aliasChain;
+			tokens[rootRef].aliasedBy = modeValue.aliasedBy;
+			tokens[rootRef].aliasOf = modeValue.aliasOf;
+			tokens[rootRef].dependencies = modeValue.dependencies;
+			tokens[rootRef].partialAliasOf = modeValue.partialAliasOf;
 		}
 	}
-	if (!hasName) errors.push({
-		...entry,
-		message: `Missing "name".`,
-		node
-	});
-	if (!hasType) errors.push({
-		...entry,
-		message: `"type": "modifier" missing.`,
-		node
-	});
-	if (!hasContexts) errors.push({
-		...entry,
-		message: `Missing "contexts".`,
-		node
-	});
-	return errors;
 }
-
-//#endregion
-//#region src/parse/normalize.ts
 /**
-* Normalize token value.
-* The reason for the “any” typing is this aligns various user-provided inputs to the type
+* Convert Reference Object to token ID.
+* This can then be turned into an alias by surrounding with { … }
+* ⚠️ This is not mode-aware. This will flatten multiple modes into the same root token.
 */
-function normalize(token, { logger, src }) {
-	const entry = {
-		group: "parser",
-		label: "init",
-		src
-	};
-	function normalizeFontFamily(value) {
-		return typeof value === "string" ? [value] : value;
-	}
-	function normalizeFontWeight(value) {
-		return typeof value === "string" && FONT_WEIGHTS[value] || value;
-	}
-	function normalizeColor(value, node) {
-		if (typeof value === "string" && !isAlias(value)) {
-			logger.warn({
-				...entry,
-				node,
-				message: `${token.id}: string colors will be deprecated in a future version. Please update to object notation`
-			});
-			try {
-				return parseColor(value);
-			} catch {
-				return {
-					colorSpace: "srgb",
-					components: [
-						0,
-						0,
-						0
-					],
-					alpha: 1
-				};
-			}
-		} else if (value && typeof value === "object") {
-			if (value.alpha === void 0) value.alpha = 1;
-		}
-		return value;
+function refToTokenID($ref) {
+	const path = typeof $ref === "object" ? $ref.$ref : $ref;
+	if (typeof path !== "string") return;
+	const { subpath } = parseRef(path);
+	if (subpath?.[0] === "$defs") subpath.splice(0, 2);
+	return subpath?.length && subpath.join(".").replace(/\.(\$root|\$value|\$extensions).*$/, "") || void 0;
+}
+const EXPECTED_NESTED_ALIAS = {
+	border: {
+		color: ["color"],
+		stroke: ["strokeStyle"],
+		width: ["dimension"]
+	},
+	gradient: {
+		color: ["color"],
+		position: ["number"]
+	},
+	shadow: {
+		color: ["color"],
+		offsetX: ["dimension"],
+		offsetY: ["dimension"],
+		blur: ["dimension"],
+		spread: ["dimension"],
+		inset: ["boolean"]
+	},
+	strokeStyle: { dashArray: ["dimension"] },
+	transition: {
+		duration: ["duration"],
+		delay: ["duration"],
+		timingFunction: ["cubicBezier"]
+	},
+	typography: {
+		fontFamily: ["fontFamily"],
+		fontWeight: ["fontWeight"],
+		fontSize: ["dimension"],
+		lineHeight: ["dimension", "number"],
+		letterSpacing: ["dimension"],
+		paragraphSpacing: ["dimension", "string"],
+		wordSpacing: ["dimension", "string"]
 	}
-	switch (token.$type) {
-		case "color":
-			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeColor(token.mode[mode].$value, token.mode[mode].source.node);
-			token.$value = token.mode["."].$value;
-			break;
-		case "fontFamily":
-			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeFontFamily(token.mode[mode].$value);
-			token.$value = token.mode["."].$value;
-			break;
-		case "fontWeight":
-			for (const mode of Object.keys(token.mode)) token.mode[mode].$value = normalizeFontWeight(token.mode[mode].$value);
-			token.$value = token.mode["."].$value;
-			break;
-		case "border":
-			for (const mode of Object.keys(token.mode)) {
-				const border = token.mode[mode].$value;
-				if (!border || typeof border !== "object") continue;
-				if (border.color) border.color = normalizeColor(border.color, getObjMember(token.mode[mode].source.node, "color"));
-			}
-			token.$value = token.mode["."].$value;
-			break;
-		case "shadow":
-			for (const mode of Object.keys(token.mode)) {
-				if (!Array.isArray(token.mode[mode].$value)) token.mode[mode].$value = [token.mode[mode].$value];
-				const $value = token.mode[mode].$value;
-				for (let i = 0; i < $value.length; i++) {
-					const shadow = $value[i];
-					if (!shadow || typeof shadow !== "object") continue;
-					const shadowNode = token.mode[mode].source.node.type === "Array" ? token.mode[mode].source.node.elements[i].value : token.mode[mode].source.node;
-					if (shadow.color) shadow.color = normalizeColor(shadow.color, getObjMember(shadowNode, "color"));
-					if (!("inset" in shadow)) shadow.inset = false;
+};
+/**
+* Resolve DTCG aliases, $extends, and $ref
+*/
+function resolveAliases(tokens, { logger, refMap, sources }) {
+	for (const token of Object.values(tokens)) {
+		const aliasEntry = {
+			group: "parser",
+			label: "init",
+			src: sources[token.source.filename]?.src,
+			node: getObjMember(token.source.node, "$value")
+		};
+		for (const mode of Object.keys(token.mode)) {
+			function resolveInner(alias, refChain) {
+				const nextRef = aliasToTokenRef(alias, mode)?.$ref;
+				if (!nextRef) {
+					logger.error({
+						...aliasEntry,
+						message: `Internal error resolving ${JSON.stringify(refChain)}`
+					});
+					throw new Error("Internal error");
 				}
+				if (refChain.includes(nextRef)) logger.error({
+					...aliasEntry,
+					message: "Circular alias detected."
+				});
+				const nextJSONID = nextRef.replace(/\/(\$value|\$extensions).*/, "");
+				const nextToken = tokens[nextJSONID]?.mode[mode] || tokens[nextJSONID]?.mode["."];
+				if (!nextToken) logger.error({
+					...aliasEntry,
+					message: `Could not resolve alias ${alias}.`
+				});
+				refChain.push(nextRef);
+				if (isAlias(nextToken.originalValue)) return resolveInner(nextToken.originalValue, refChain);
+				return nextJSONID;
 			}
-			token.$value = token.mode["."].$value;
-			break;
-		case "gradient":
-			for (const mode of Object.keys(token.mode)) {
-				if (!Array.isArray(token.mode[mode].$value)) continue;
-				const $value = token.mode[mode].$value;
-				for (let i = 0; i < $value.length; i++) {
-					const stop = $value[i];
-					if (!stop || typeof stop !== "object") continue;
-					const stopNode = token.mode[mode].source.node?.elements?.[i]?.value;
-					if (stop.color) stop.color = normalizeColor(stop.color, getObjMember(stopNode, "color"));
+			function traverseAndResolve(value, { node, expectedTypes, path }) {
+				if (typeof value !== "string") {
+					if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+						if (!value[i]) continue;
+						value[i] = traverseAndResolve(value[i], {
+							node: node.elements?.[i]?.value,
+							expectedTypes: expectedTypes?.includes("cubicBezier") ? ["number"] : expectedTypes,
+							path: [...path, i]
+						}).$value;
+					}
+					else if (typeof value === "object") for (const key of Object.keys(value)) {
+						if (!expectedTypes?.length || !EXPECTED_NESTED_ALIAS[expectedTypes[0]]) continue;
+						value[key] = traverseAndResolve(value[key], {
+							node: getObjMember(node, key),
+							expectedTypes: EXPECTED_NESTED_ALIAS[expectedTypes[0]][key],
+							path: [...path, key]
+						}).$value;
+					}
+					return { $value: value };
 				}
-			}
-			token.$value = token.mode["."].$value;
-			break;
-		case "typography":
-			for (const mode of Object.keys(token.mode)) {
-				const $value = token.mode[mode].$value;
-				if (typeof $value !== "object") return;
-				for (const [k, v] of Object.entries($value)) switch (k) {
-					case "fontFamily":
-						$value[k] = normalizeFontFamily(v);
-						break;
-					case "fontWeight":
-						$value[k] = normalizeFontWeight(v);
-						break;
+				if (!isAlias(value)) {
+					if (!expectedTypes?.includes("string") && (value.includes("{") || value.includes("}"))) logger.error({
+						...aliasEntry,
+						message: "Invalid alias syntax.",
+						node
+					});
+					return { $value: value };
 				}
+				const refChain = [];
+				const resolvedID = resolveInner(value, refChain);
+				if (expectedTypes?.length && !expectedTypes.includes(tokens[resolvedID].$type)) logger.error({
+					...aliasEntry,
+					message: `Cannot alias to $type "${tokens[resolvedID].$type}" from $type "${expectedTypes.join(" / ")}".`,
+					node
+				});
+				refMap[path.join("/")] = {
+					filename: token.source.filename,
+					refChain
+				};
+				return {
+					$type: tokens[resolvedID].$type,
+					$value: tokens[resolvedID].mode[mode]?.$value || tokens[resolvedID].$value
+				};
 			}
-			token.$value = token.mode["."].$value;
-			break;
+			const pathBase = mode === "." ? token.jsonID : `${token.jsonID}/$extensions/mode/${mode}`;
+			const { $type, $value } = traverseAndResolve(token.mode[mode].$value, {
+				node: aliasEntry.node,
+				expectedTypes: token.$type ? [token.$type] : void 0,
+				path: [pathBase, "$value"]
+			});
+			if (!token.$type) token.$type = $type;
+			if ($value) token.mode[mode].$value = $value;
+			if (mode === ".") token.$value = token.mode[mode].$value;
+		}
 	}
 }
 
 //#endregion
-//#region src/parse/token.ts
-/** Convert valid DTCG alias to $ref */
-function aliasToGroupRef(alias) {
-	const id = parseAlias(alias);
-	if (id === alias) return;
-	return { $ref: `#/${id.replace(/~/g, "~0").replace(/\//g, "~1").replace(/\./g, "/")}` };
-}
-/** Convert valid DTCG alias to $ref */
-function aliasToTokenRef(alias, mode) {
-	const id = parseAlias(alias);
-	if (id === alias) return;
-	return { $ref: `#/${id.replace(/~/g, "~0").replace(/\//g, "~1").replace(/\./g, "/")}${mode && mode !== "." ? `/$extensions/mode/${mode}` : ""}/$value` };
-}
-/** Generate a TokenNormalized from a Momoa node */
-function tokenFromNode(node, { groups, path, source, ignore }) {
-	if (!(node.type === "Object" && !!getObjMember(node, "$value") && !path.includes("$extensions"))) return;
-	const jsonID = encodeFragment(path);
-	const id = path.join(".");
-	const originalToken = momoa.evaluate(node);
-	const group = groups[encodeFragment(path.slice(0, -1))];
-	if (group?.tokens && !group.tokens.includes(id)) group.tokens.push(id);
-	const nodeSource = {
-		filename: source.filename.href,
-		node
+//#region src/parse/process.ts
+function processTokens(rootSource, { config, logger, sourceByFilename, isResolver }) {
+	const entry = {
+		group: "parser",
+		label: "init"
 	};
-	const token = {
-		id,
-		$type: originalToken.$type || group.$type,
-		$description: originalToken.$description || void 0,
-		$deprecated: originalToken.$deprecated ?? group.$deprecated ?? void 0,
-		$value: originalToken.$value,
-		$extensions: originalToken.$extensions || void 0,
-		$extends: originalToken.$extends || void 0,
-		aliasChain: void 0,
-		aliasedBy: void 0,
-		aliasOf: void 0,
-		partialAliasOf: void 0,
-		dependencies: void 0,
-		group,
-		originalValue: void 0,
-		source: nodeSource,
-		jsonID,
-		mode: { ".": {
-			$value: originalToken.$value,
-			aliasOf: void 0,
-			aliasChain: void 0,
-			partialAliasOf: void 0,
-			aliasedBy: void 0,
-			originalValue: void 0,
-			dependencies: void 0,
-			source: {
-				...nodeSource,
-				node: getObjMember(nodeSource.node, "$value") ?? nodeSource.node
+	const refMap = {};
+	function resolveRef(node, chain) {
+		const { subpath } = parseRef(node.value);
+		assert(subpath, logger, {
+			...entry,
+			message: "Can’t resolve $ref",
+			node,
+			src: rootSource.src
+		});
+		const next = findNode(rootSource.document, subpath);
+		assert(next, logger, {
+			...entry,
+			message: "Can't find $ref",
+			node,
+			src: rootSource.src
+		});
+		if (next?.type === "Object") {
+			const next$ref = getObjMember(next, "$ref");
+			if (next$ref && next$ref.type === "String") {
+				if (chain.includes(next$ref.value)) logger.error({
+					...entry,
+					message: `Circular $ref detected: ${JSON.stringify(next$ref.value)}`,
+					node: next$ref,
+					src: rootSource.src
+				});
+				chain.push(next$ref.value);
+				return resolveRef(next$ref, chain);
+			}
+		}
+		return next;
+	}
+	const inlineStart = performance.now();
+	traverse(rootSource.document, { enter(node, _parent, rawPath) {
+		if (rawPath.includes("$extensions") || node.type !== "Object") return;
+		const $ref = node.type === "Object" ? getObjMember(node, "$ref") : void 0;
+		if (!$ref) return;
+		assertStringNode($ref, logger, {
+			...entry,
+			message: "Invalid $ref. Expected string.",
+			node: $ref,
+			src: rootSource.src
+		});
+		const jsonID = encodeFragment(rawPath);
+		refMap[jsonID] = {
+			filename: rootSource.filename.href,
+			refChain: [$ref.value]
+		};
+		const resolved = resolveRef($ref, refMap[jsonID].refChain);
+		if (resolved.type === "Object") {
+			node.members.splice(node.members.findIndex((m) => m.name.type === "String" && m.name.value === "$ref"), 1);
+			replaceNode(node, mergeObjects(resolved, node));
+		} else replaceNode(node, resolved);
+	} });
+	logger.debug({
+		...entry,
+		message: "Inline aliases",
+		timing: performance.now() - inlineStart
+	});
+	function flatten$extends(node, chain) {
+		const memberKeys = node.members.map((m) => m.name.type === "String" && m.name.value).filter(Boolean);
+		if (memberKeys.includes("$extends")) {
+			const $extends = getObjMember(node, "$extends");
+			assertStringNode($extends, logger, {
+				...entry,
+				message: "$extends must be a string",
+				node: $extends,
+				src: rootSource.src
+			});
+			if (memberKeys.includes("$value")) logger.error({
+				...entry,
+				message: "$extends can’t exist within a token",
+				node: $extends,
+				src: rootSource.src
+			});
+			const next = isAlias($extends.value) ? aliasToGroupRef($extends.value) : void 0;
+			assert(next, logger, {
+				...entry,
+				message: "$extends must be a valid alias",
+				node: $extends,
+				src: rootSource.src
+			});
+			if (chain.includes(next.$ref) || chain.some((value) => value.startsWith(next.$ref) || next.$ref.startsWith(value))) logger.error({
+				...entry,
+				message: "Circular $extends detected",
+				node: $extends,
+				src: rootSource.src
+			});
+			chain.push(next.$ref);
+			const extended = findNode(rootSource.document, parseRef(next.$ref).subpath ?? []);
+			assert(extended, logger, {
+				...entry,
+				message: "Could not resolve $extends",
+				node: $extends,
+				src: rootSource.src
+			});
+			assertObjectNode(extended, logger, {
+				...entry,
+				message: "$extends must resolve to a group of tokens",
+				node
+			});
+			flatten$extends(extended, chain);
+			replaceNode(node, mergeObjects(extended, node));
+		}
+		for (const member of node.members) if (member.value.type === "Object" && member.name.type === "String" && !["$value", "$extensions"].includes(member.name.value)) traverse(member.value, { enter(subnode, _parent) {
+			if (subnode.type === "Object") flatten$extends(subnode, chain);
+		} });
+	}
+	const extendsStart = performance.now();
+	flatten$extends(rootSource.document.body, []);
+	logger.debug({
+		...entry,
+		message: "Resolving $extends",
+		timing: performance.now() - extendsStart
+	});
+	const firstPass = performance.now();
+	const tokens = {};
+	const tokenIDs = [];
+	const groups = {};
+	traverse(rootSource.document, { enter(node, _parent, rawPath) {
+		if (node.type !== "Object") return;
+		groupFromNode(node, {
+			path: isResolver ? filterResolverPaths(rawPath) : rawPath,
+			groups
+		});
+		const token = tokenFromNode(node, {
+			groups,
+			ignore: config.ignore,
+			path: isResolver ? filterResolverPaths(rawPath) : rawPath,
+			source: rootSource
+		});
+		if (token) {
+			tokenIDs.push(token.jsonID);
+			tokens[token.jsonID] = token;
+		}
+	} });
+	logger.debug({
+		...entry,
+		message: "Parsing: 1st pass",
+		timing: performance.now() - firstPass
+	});
+	const secondPass = performance.now();
+	for (const source of Object.values(sourceByFilename)) traverse(source.document, { enter(node, _parent, path) {
+		if (node.type !== "Object") return;
+		const tokenRawValues = tokenRawValuesFromNode(node, {
+			filename: source.filename.href,
+			path
+		});
+		if (tokenRawValues && tokens[tokenRawValues?.jsonID]) {
+			tokens[tokenRawValues.jsonID].originalValue = tokenRawValues.originalValue;
+			tokens[tokenRawValues.jsonID].source = tokenRawValues.source;
+			for (const mode of Object.keys(tokenRawValues.mode)) {
+				tokens[tokenRawValues.jsonID].mode[mode].originalValue = tokenRawValues.mode[mode].originalValue;
+				tokens[tokenRawValues.jsonID].mode[mode].source = tokenRawValues.mode[mode].source;
 			}
-		} }
-	};
-	if (ignore?.deprecated && token.$deprecated || ignore?.tokens && wcmatch(ignore.tokens)(token.id)) return;
-	const $extensions = getObjMember(node, "$extensions");
-	if ($extensions) {
-		const modeNode = getObjMember($extensions, "mode");
-		for (const mode of Object.keys(token.$extensions.mode ?? {})) {
-			const modeValue = token.$extensions.mode[mode];
-			token.mode[mode] = {
-				$value: modeValue,
-				aliasOf: void 0,
-				aliasChain: void 0,
-				partialAliasOf: void 0,
-				aliasedBy: void 0,
-				originalValue: void 0,
-				dependencies: void 0,
-				source: {
-					...nodeSource,
-					node: getObjMember(modeNode, mode)
-				}
-			};
 		}
+	} });
+	resolveAliases(tokens, {
+		logger,
+		sources: sourceByFilename,
+		refMap
+	});
+	logger.debug({
+		...entry,
+		message: "Parsing: 2nd pass",
+		timing: performance.now() - secondPass
+	});
+	const aliasStart = performance.now();
+	graphAliases(refMap, {
+		tokens,
+		logger,
+		sources: sourceByFilename
+	});
+	logger.debug({
+		...entry,
+		message: "Alias graph built",
+		timing: performance.now() - aliasStart
+	});
+	const normalizeStart = performance.now();
+	for (const id of tokenIDs) {
+		const token = tokens[id];
+		normalize(token, {
+			logger,
+			src: sourceByFilename[token.source.filename]?.src
+		});
 	}
-	return token;
+	logger.debug({
+		...entry,
+		message: "Normalized values",
+		timing: performance.now() - normalizeStart
+	});
+	if (config.alphabetize === false) return tokens;
+	const sortStart = performance.now();
+	const tokensSorted = {};
+	tokenIDs.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
+	for (const path of tokenIDs) {
+		const id = refToTokenID(path);
+		tokensSorted[id] = tokens[path];
+	}
+	for (const group of Object.values(groups)) group.tokens.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
+	logger.debug({
+		...entry,
+		message: "Sorted tokens",
+		timing: performance.now() - sortStart
+	});
+	return tokensSorted;
 }
-/** Generate originalValue and source from node */
-function tokenRawValuesFromNode(node, { filename, path }) {
-	if (!(node.type === "Object" && getObjMember(node, "$value") && !path.includes("$extensions"))) return;
-	const rawValues = {
-		jsonID: encodeFragment(path),
-		originalValue: momoa.evaluate(node),
-		source: {
-			loc: filename,
+
+//#endregion
+//#region src/resolver/normalize.ts
+/** Normalize resolver (assuming it’s been validated) */
+async function normalizeResolver(document, { logger, filename, req, src, yamlToMomoa }) {
+	const resolverBundle = await bundle([{
+		filename,
+		src
+	}], {
+		req,
+		yamlToMomoa
+	});
+	const resolverSource = momoa.evaluate(resolverBundle.document);
+	replaceNode(document, resolverBundle.document);
+	for (const set of Object.values(resolverSource.sets ?? {})) for (const source of set.sources) resolvePartials(source, {
+		resolver: resolverSource,
+		logger
+	});
+	for (const modifier of Object.values(resolverSource.modifiers ?? {})) for (const context of Object.values(modifier.contexts)) for (const source of context) resolvePartials(source, {
+		resolver: resolverSource,
+		logger
+	});
+	for (const item of resolverSource.resolutionOrder ?? []) resolvePartials(item, {
+		resolver: resolverSource,
+		logger
+	});
+	return {
+		name: resolverSource.name,
+		version: resolverSource.version,
+		description: resolverSource.description,
+		sets: resolverSource.sets,
+		modifiers: resolverSource.modifiers,
+		resolutionOrder: resolverSource.resolutionOrder,
+		_source: {
 			filename,
-			node
-		},
-		mode: {}
-	};
-	rawValues.mode["."] = {
-		originalValue: rawValues.originalValue.$value,
-		source: {
-			...rawValues.source,
-			node: getObjMember(node, "$value")
+			document
 		}
 	};
-	const $extensions = getObjMember(node, "$extensions");
-	if ($extensions) {
-		const modes = getObjMember($extensions, "mode");
-		if (modes) for (const modeMember of modes.members) {
-			const mode = modeMember.name.value;
-			rawValues.mode[mode] = {
-				originalValue: momoa.evaluate(modeMember.value),
-				source: {
-					loc: filename,
-					filename,
-					node: modeMember.value
-				}
-			};
-		}
-	}
-	return rawValues;
 }
-/** Arbitrary keys that should be associated with a token group */
-const GROUP_PROPERTIES = [
-	"$deprecated",
-	"$description",
-	"$extensions",
-	"$type"
-];
-/**
-* Generate a group from a node.
-* This method mutates the groups index as it goes because of group inheritance.
-* As it encounters new groups it may have to update other groups.
-*/
-function groupFromNode(node, { path, groups }) {
-	const id = path.join(".");
-	const jsonID = encodeFragment(path);
-	if (!groups[jsonID]) groups[jsonID] = {
-		id,
-		$deprecated: void 0,
-		$description: void 0,
-		$extensions: void 0,
-		$type: void 0,
-		tokens: []
+/** Resolve $refs for already-initialized JS */
+function resolvePartials(source, { resolver, logger }) {
+	if (!source) return;
+	const entry = {
+		group: "parser",
+		label: "resolver"
 	};
-	const groupIDs = Object.keys(groups);
-	groupIDs.sort();
-	for (const groupID of groupIDs) if (jsonID.startsWith(groupID) && groupID !== jsonID) {
-		groups[jsonID].$deprecated = groups[groupID]?.$deprecated ?? groups[jsonID].$deprecated;
-		groups[jsonID].$description = groups[groupID]?.$description ?? groups[jsonID].$description;
-		groups[jsonID].$type = groups[groupID]?.$type ?? groups[jsonID].$type;
-	}
-	for (const m of node.members) {
-		if (m.name.type !== "String" || !GROUP_PROPERTIES.includes(m.name.value)) continue;
-		groups[jsonID][m.name.value] = momoa.evaluate(m.value);
-	}
-	return groups[jsonID];
-}
-/**
-* Link and reverse-link tokens in one pass.
-*/
-function graphAliases(refMap, { tokens, logger, sources }) {
-	const getTokenRef = (ref) => ref.replace(/\/(\$value|\$extensions)\/?.*/, "");
-	for (const [jsonID, { refChain }] of Object.entries(refMap)) {
-		if (!refChain.length) continue;
-		const mode = jsonID.match(/\/\$extensions\/mode\/([^/]+)/)?.[1] || ".";
-		const rootRef = getTokenRef(jsonID);
-		const modeValue = tokens[rootRef]?.mode[mode];
-		if (!modeValue) continue;
-		if (!modeValue.dependencies) modeValue.dependencies = [];
-		modeValue.dependencies.push(...refChain.filter((r) => !modeValue.dependencies.includes(r)));
-		modeValue.dependencies.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
-		if (jsonID.endsWith("/$value") || tokens[jsonID]) {
-			modeValue.aliasOf = refToTokenID(refChain.at(-1));
-			modeValue.aliasChain = [...refChain.map(refToTokenID)];
-		}
-		const partial = jsonID.replace(/.*\/\$value\/?/, "").split("/").filter(Boolean);
-		if (partial.length && modeValue.$value && typeof modeValue.$value === "object") {
-			let node = modeValue.$value;
-			let sourceNode = modeValue.source.node;
-			if (!modeValue.partialAliasOf) modeValue.partialAliasOf = Array.isArray(modeValue.$value) || tokens[rootRef]?.$type === "shadow" ? [] : {};
-			let partialAliasOf = modeValue.partialAliasOf;
-			if (tokens[rootRef]?.$type === "shadow" && !Array.isArray(node)) {
-				if (Array.isArray(modeValue.partialAliasOf) && !modeValue.partialAliasOf.length) modeValue.partialAliasOf.push({});
-				partialAliasOf = modeValue.partialAliasOf[0];
-			}
-			for (let i = 0; i < partial.length; i++) {
-				let key = partial[i];
-				if (String(Number(key)) === key) key = Number(key);
-				if (key in node && typeof node[key] !== "undefined") {
-					node = node[key];
-					if (sourceNode.type === "Object") sourceNode = getObjMember(sourceNode, key) ?? sourceNode;
-					else if (sourceNode.type === "Array") sourceNode = sourceNode.elements[key]?.value ?? sourceNode;
-				}
-				if (i === partial.length - 1) {
-					const aliasedID = getTokenRef(refChain[0]);
-					if (!(aliasedID in tokens)) {
-						logger.error({
-							group: "parser",
-							label: "init",
-							message: `Invalid alias: ${aliasedID}`,
-							node: sourceNode,
-							src: sources[tokens[rootRef].source.filename]?.src
-						});
-						break;
-					}
-					partialAliasOf[key] = refToTokenID(aliasedID);
-				}
-				if (!(key in partialAliasOf)) partialAliasOf[key] = Array.isArray(node) ? [] : {};
-				partialAliasOf = partialAliasOf[key];
-			}
-		}
-		const aliasedByRefs = [jsonID, ...refChain].reverse();
-		for (let i = 0; i < aliasedByRefs.length; i++) {
-			const baseRef = getTokenRef(aliasedByRefs[i]);
-			const baseToken = tokens[baseRef]?.mode[mode] || tokens[baseRef];
-			if (!baseToken) continue;
-			const upstream = aliasedByRefs.slice(i + 1);
-			if (!upstream.length) break;
-			if (!baseToken.aliasedBy) baseToken.aliasedBy = [];
-			for (let j = 0; j < upstream.length; j++) {
-				const downstream = refToTokenID(upstream[j]);
-				if (!baseToken.aliasedBy.includes(downstream)) {
-					baseToken.aliasedBy.push(downstream);
-					if (mode === ".") tokens[baseRef].aliasedBy = baseToken.aliasedBy;
-				}
-			}
-			baseToken.aliasedBy.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
-		}
-		if (mode === ".") {
-			tokens[rootRef].aliasChain = modeValue.aliasChain;
-			tokens[rootRef].aliasedBy = modeValue.aliasedBy;
-			tokens[rootRef].aliasOf = modeValue.aliasOf;
-			tokens[rootRef].dependencies = modeValue.dependencies;
-			tokens[rootRef].partialAliasOf = modeValue.partialAliasOf;
+	if (Array.isArray(source)) for (const item of source) resolvePartials(item, {
+		resolver,
+		logger
+	});
+	else if (typeof source === "object") for (const k of Object.keys(source)) if (k === "$ref") {
+		const $ref = source[k];
+		const { url, subpath = [] } = parseRef($ref);
+		if (url !== "." || !subpath.length) logger.error({
+			...entry,
+			message: `Could not load $ref ${JSON.stringify($ref)}`
+		});
+		const found = findObject(resolver, subpath ?? [], logger);
+		if (subpath[0] === "sets" || subpath[0] === "modifiers") {
+			found.type = subpath[0].replace(/s$/, "");
+			found.name = subpath[1];
 		}
+		if (found) {
+			for (const k2 of Object.keys(found)) source[k2] = found[k2];
+			delete source.$ref;
+		} else logger.error({
+			...entry,
+			message: `Could not find ${JSON.stringify($ref)}`
+		});
+	} else resolvePartials(source[k], {
+		resolver,
+		logger
+	});
+}
+function findObject(dict, path, logger) {
+	let node = dict;
+	for (const idRaw of path) {
+		const id = idRaw.replace(/~/g, "~0").replace(/\//g, "~1");
+		if (!(id in node)) logger.error({
+			group: "parser",
+			label: "resolver",
+			message: `Could not load $ref ${encodeFragment(path)}`
+		});
+		node = node[id];
 	}
+	return node;
 }
+
+//#endregion
+//#region src/resolver/validate.ts
 /**
-* Convert Reference Object to token ID.
-* This can then be turned into an alias by surrounding with { … }
-* ⚠️ This is not mode-aware. This will flatten multiple modes into the same root token.
+* Determine whether this is likely a resolver
+* We use terms the word “likely” because this occurs before validation. Since
+* we may be dealing with a doc _intended_ to be a resolver, but may be lacking
+* some critical information, how can we determine intent? There’s a bit of
+* guesswork here, but we try and find a reasonable edge case where we sniff out
+* invalid DTCG syntax that a resolver doc would have.
 */
-function refToTokenID($ref) {
-	const path = typeof $ref === "object" ? $ref.$ref : $ref;
-	if (typeof path !== "string") return;
-	const { subpath } = parseRef(path);
-	if (subpath?.[0] === "$defs") subpath.splice(0, 2);
-	return subpath?.length && subpath.join(".").replace(/\.(\$value|\$extensions).*$/, "") || void 0;
-}
-const EXPECTED_NESTED_ALIAS = {
-	border: {
-		color: ["color"],
-		stroke: ["strokeStyle"],
-		width: ["dimension"]
-	},
-	gradient: {
-		color: ["color"],
-		position: ["number"]
-	},
-	shadow: {
-		color: ["color"],
-		offsetX: ["dimension"],
-		offsetY: ["dimension"],
-		blur: ["dimension"],
-		spread: ["dimension"],
-		inset: ["boolean"]
-	},
-	strokeStyle: { dashArray: ["dimension"] },
-	transition: {
-		duration: ["duration"],
-		delay: ["duration"],
-		timingFunction: ["cubicBezier"]
-	},
-	typography: {
-		fontFamily: ["fontFamily"],
-		fontWeight: ["fontWeight"],
-		fontSize: ["dimension"],
-		lineHeight: ["dimension", "number"],
-		letterSpacing: ["dimension"]
+function isLikelyResolver(doc) {
+	if (doc.body.type !== "Object") return false;
+	for (const member of doc.body.members) {
+		if (member.name.type !== "String") continue;
+		switch (member.name.value) {
+			case "name":
+			case "description":
+			case "version":
+				if (member.value.type === "String") return true;
+				break;
+			case "sets":
+			case "modifiers":
+				if (member.value.type !== "Object") continue;
+				if (getObjMember(member.value, "description")?.type === "String") return true;
+				if (member.name.value === "sets" && getObjMember(member.value, "sources")?.type === "Array") return true;
+				else if (member.name.value === "modifiers") {
+					const contexts = getObjMember(member.value, "contexts");
+					if (contexts?.type === "Object" && contexts.members.some((m) => m.value.type === "Array")) return true;
+				}
+				break;
+			case "resolutionOrder":
+				if (member.value.type === "Array") return true;
+				break;
+		}
 	}
+	return false;
+}
+const MESSAGE_EXPECTED = {
+	STRING: "Expected string.",
+	OBJECT: "Expected object.",
+	ARRAY: "Expected array."
 };
 /**
-* Resolve DTCG aliases, $extends, and $ref
+* Validate a resolver document.
+* There’s a ton of boilerplate here, only to surface detailed code frames. Is there a better abstraction?
 */
-function resolveAliases(tokens, { logger, refMap, sources }) {
-	for (const token of Object.values(tokens)) {
-		const aliasEntry = {
-			group: "parser",
-			label: "init",
-			src: sources[token.source.filename]?.src,
-			node: getObjMember(token.source.node, "$value")
-		};
-		for (const mode of Object.keys(token.mode)) {
-			function resolveInner(alias, refChain) {
-				const nextRef = aliasToTokenRef(alias, mode)?.$ref;
-				if (!nextRef) {
-					logger.error({
-						...aliasEntry,
-						message: `Internal error resolving ${JSON.stringify(refChain)}`
-					});
-					throw new Error("Internal error");
-				}
-				if (refChain.includes(nextRef)) logger.error({
-					...aliasEntry,
-					message: "Circular alias detected."
+function validateResolver(node, { logger, src }) {
+	const entry = {
+		group: "parser",
+		label: "resolver",
+		src
+	};
+	if (node.body.type !== "Object") logger.error({
+		...entry,
+		message: MESSAGE_EXPECTED.OBJECT,
+		node
+	});
+	const errors = [];
+	let hasVersion = false;
+	let hasResolutionOrder = false;
+	for (const member of node.body.members) {
+		if (member.name.type !== "String") continue;
+		switch (member.name.value) {
+			case "name":
+			case "description":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING
 				});
-				const nextJSONID = nextRef.replace(/\/(\$value|\$extensions).*/, "");
-				const nextToken = tokens[nextJSONID]?.mode[mode] || tokens[nextJSONID]?.mode["."];
-				if (!nextToken) logger.error({
-					...aliasEntry,
-					message: `Could not resolve alias ${alias}.`
+				break;
+			case "version":
+				hasVersion = true;
+				if (member.value.type !== "String" || member.value.value !== "2025.10") errors.push({
+					...entry,
+					message: `Expected "version" to be "2025.10".`,
+					node: member.value
 				});
-				refChain.push(nextRef);
-				if (isAlias(nextToken.originalValue)) return resolveInner(nextToken.originalValue, refChain);
-				return nextJSONID;
-			}
-			function traverseAndResolve(value, { node, expectedTypes, path }) {
-				if (typeof value !== "string") {
-					if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
-						if (!value[i]) continue;
-						value[i] = traverseAndResolve(value[i], {
-							node: node.elements?.[i]?.value,
-							expectedTypes: expectedTypes?.includes("cubicBezier") ? ["number"] : expectedTypes,
-							path: [...path, i]
-						}).$value;
-					}
-					else if (typeof value === "object") for (const key of Object.keys(value)) {
-						if (!expectedTypes?.length || !EXPECTED_NESTED_ALIAS[expectedTypes[0]]) continue;
-						value[key] = traverseAndResolve(value[key], {
-							node: getObjMember(node, key),
-							expectedTypes: EXPECTED_NESTED_ALIAS[expectedTypes[0]][key],
-							path: [...path, key]
-						}).$value;
-					}
-					return { $value: value };
+				break;
+			case "sets":
+			case "modifiers":
+				if (member.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: member.value
+				});
+				else for (const item of member.value.members) if (item.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: item.value
+				});
+				else {
+					const validator = member.name.value === "sets" ? validateSet : validateModifier;
+					errors.push(...validator(item.value, false, {
+						logger,
+						src
+					}));
 				}
-				if (!isAlias(value)) {
-					if (!expectedTypes?.includes("string") && (value.includes("{") || value.includes("}"))) logger.error({
-						...aliasEntry,
-						message: "Invalid alias syntax.",
-						node
+				break;
+			case "resolutionOrder":
+				hasResolutionOrder = true;
+				if (member.value.type !== "Array") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.ARRAY,
+					node: member.value
+				});
+				else if (member.value.elements.length === 0) errors.push({
+					...entry,
+					message: `"resolutionOrder" can’t be empty array.`,
+					node: member.value
+				});
+				else for (const item of member.value.elements) if (item.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: item.value
+				});
+				else {
+					const itemMembers = getObjMembers(item.value);
+					if (itemMembers.$ref?.type === "String") continue;
+					if (itemMembers.type?.type === "String") if (itemMembers.type.value === "set") validateSet(item.value, true, {
+						logger,
+						src
+					});
+					else if (itemMembers.type.value === "modifier") validateModifier(item.value, true, {
+						logger,
+						src
+					});
+					else errors.push({
+						...entry,
+						message: `Unknown type ${JSON.stringify(itemMembers.type.value)}`,
+						node: itemMembers.type
+					});
+					if (itemMembers.sources?.type === "Array") validateSet(item.value, true, {
+						logger,
+						src
+					});
+					else if (itemMembers.contexts?.type === "Object") validateModifier(item.value, true, {
+						logger,
+						src
+					});
+					else if (itemMembers.name?.type === "String" || itemMembers.description?.type === "String") validateSet(item.value, true, {
+						logger,
+						src
 					});
-					return { $value: value };
 				}
-				const refChain = [];
-				const resolvedID = resolveInner(value, refChain);
-				if (expectedTypes?.length && !expectedTypes.includes(tokens[resolvedID].$type)) logger.error({
-					...aliasEntry,
-					message: `Cannot alias to $type "${tokens[resolvedID].$type}" from $type "${expectedTypes.join(" / ")}".`,
-					node
+				break;
+			case "$defs":
+			case "$extensions":
+				if (member.value.type !== "Object") errors.push({
+					...entry,
+					message: `Expected object`,
+					node: member.value
+				});
+				break;
+			case "$schema":
+			case "$ref":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: `Expected string`,
+					node: member.value
 				});
-				refMap[path.join("/")] = {
-					filename: token.source.filename,
-					refChain
-				};
-				return {
-					$type: tokens[resolvedID].$type,
-					$value: tokens[resolvedID].mode[mode]?.$value || tokens[resolvedID].$value
-				};
-			}
-			const pathBase = mode === "." ? token.jsonID : `${token.jsonID}/$extensions/mode/${mode}`;
-			const { $type, $value } = traverseAndResolve(token.mode[mode].$value, {
-				node: aliasEntry.node,
-				expectedTypes: token.$type ? [token.$type] : void 0,
-				path: [pathBase, "$value"]
-			});
-			if (!token.$type) token.$type = $type;
-			if ($value) token.mode[mode].$value = $value;
-			if (mode === ".") token.$value = token.mode[mode].$value;
-		}
-	}
-}
-
-//#endregion
-//#region src/parse/process.ts
-function processTokens(rootSource, { config, logger, sourceByFilename }) {
-	const entry = {
-		group: "parser",
-		label: "init"
-	};
-	const refMap = {};
-	function resolveRef(node, chain) {
-		const { subpath } = parseRef(node.value);
-		if (!subpath) logger.error({
-			...entry,
-			message: "Can’t resolve $ref",
-			node,
-			src: rootSource.src
-		});
-		const next = findNode(rootSource.document, subpath);
-		if (next?.type === "Object") {
-			const next$ref = getObjMember(next, "$ref");
-			if (next$ref && next$ref.type === "String") {
-				if (chain.includes(next$ref.value)) logger.error({
+				break;
+			default:
+				errors.push({
 					...entry,
-					message: `Circular $ref detected: ${JSON.stringify(next$ref.value)}`,
-					node: next$ref,
-					src: rootSource.src
+					message: `Unknown key ${JSON.stringify(member.name.value)}`,
+					node: member.name,
+					src
 				});
-				chain.push(next$ref.value);
-				return resolveRef(next$ref, chain);
-			}
-		}
-		return next;
-	}
-	const inlineStart = performance.now();
-	traverse(rootSource.document, { enter(node, _parent, rawPath) {
-		if (rawPath.includes("$extensions") || node.type !== "Object") return;
-		const $ref = node.type === "Object" ? getObjMember(node, "$ref") : void 0;
-		if (!$ref) return;
-		if ($ref.type !== "String") logger.error({
-			...entry,
-			message: "Invalid $ref. Expected string.",
-			node: $ref,
-			src: rootSource.src
-		});
-		const jsonID = encodeFragment(rawPath);
-		refMap[jsonID] = {
-			filename: rootSource.filename.href,
-			refChain: [$ref.value]
-		};
-		const resolved = resolveRef($ref, refMap[jsonID].refChain);
-		if (resolved.type === "Object") {
-			node.members.splice(node.members.findIndex((m) => m.name.type === "String" && m.name.value === "$ref"), 1);
-			replaceNode(node, mergeObjects(resolved, node));
-		} else replaceNode(node, resolved);
-	} });
-	logger.debug({
-		...entry,
-		message: "Inline aliases",
-		timing: performance.now() - inlineStart
-	});
-	function flatten$extends(node, chain) {
-		const memberKeys = node.members.map((m) => m.name.type === "String" && m.name.value).filter(Boolean);
-		let extended;
-		if (memberKeys.includes("$extends")) {
-			const $extends = getObjMember(node, "$extends");
-			if ($extends.type !== "String") logger.error({
-				...entry,
-				message: "$extends must be a string",
-				node: $extends,
-				src: rootSource.src
-			});
-			if (memberKeys.includes("$value")) logger.error({
-				...entry,
-				message: "$extends can’t exist within a token",
-				node: $extends,
-				src: rootSource.src
-			});
-			const next = isAlias($extends.value) ? aliasToGroupRef($extends.value) : void 0;
-			if (!next) logger.error({
-				...entry,
-				message: "$extends must be a valid alias",
-				node: $extends,
-				src: rootSource.src
-			});
-			if (chain.includes(next.$ref) || chain.some((value) => value.startsWith(next.$ref) || next.$ref.startsWith(value))) logger.error({
-				...entry,
-				message: "Circular $extends detected",
-				node: $extends,
-				src: rootSource.src
-			});
-			chain.push(next.$ref);
-			extended = findNode(rootSource.document, parseRef(next.$ref).subpath ?? []);
-			if (!extended) logger.error({
-				...entry,
-				message: "Could not resolve $extends",
-				node: $extends,
-				src: rootSource.src
-			});
-			if (extended.type !== "Object") logger.error({
-				...entry,
-				message: "$extends must resolve to a group of tokens",
-				node
-			});
-			flatten$extends(extended, chain);
-			replaceNode(node, mergeObjects(extended, node));
+				break;
 		}
-		for (const member of node.members) if (member.value.type === "Object" && member.name.type === "String" && !["$value", "$extensions"].includes(member.name.value)) traverse(member.value, { enter(subnode, _parent) {
-			if (subnode.type === "Object") flatten$extends(subnode, chain);
-		} });
 	}
-	const extendsStart = performance.now();
-	flatten$extends(rootSource.document.body, []);
-	logger.debug({
+	if (!hasVersion) errors.push({
 		...entry,
-		message: "Resolving $extends",
-		timing: performance.now() - extendsStart
+		message: `Missing "version".`,
+		node,
+		src
 	});
-	const firstPass = performance.now();
-	const tokens = {};
-	const tokenIDs = [];
-	const groups = {};
-	const isResolver = isLikelyResolver(rootSource.document);
-	traverse(rootSource.document, { enter(node, _parent, rawPath) {
-		if (node.type !== "Object") return;
-		groupFromNode(node, {
-			path: isResolver ? filterResolverPaths(rawPath) : rawPath,
-			groups
-		});
-		const token = tokenFromNode(node, {
-			groups,
-			ignore: config.ignore,
-			path: isResolver ? filterResolverPaths(rawPath) : rawPath,
-			source: rootSource
-		});
-		if (token) {
-			tokenIDs.push(token.jsonID);
-			tokens[token.jsonID] = token;
-		}
-	} });
-	logger.debug({
+	if (!hasResolutionOrder) errors.push({
 		...entry,
-		message: "Parsing: 1st pass",
-		timing: performance.now() - firstPass
+		message: `Missing "resolutionOrder".`,
+		node,
+		src
 	});
-	const secondPass = performance.now();
-	for (const source of Object.values(sourceByFilename)) traverse(source.document, { enter(node, _parent, path) {
-		if (node.type !== "Object") return;
-		const tokenRawValues = tokenRawValuesFromNode(node, {
-			filename: source.filename.href,
-			path
-		});
-		if (tokenRawValues && tokens[tokenRawValues?.jsonID]) {
-			tokens[tokenRawValues.jsonID].originalValue = tokenRawValues.originalValue;
-			tokens[tokenRawValues.jsonID].source = tokenRawValues.source;
-			for (const mode of Object.keys(tokenRawValues.mode)) {
-				tokens[tokenRawValues.jsonID].mode[mode].originalValue = tokenRawValues.mode[mode].originalValue;
-				tokens[tokenRawValues.jsonID].mode[mode].source = tokenRawValues.mode[mode].source;
-			}
+	if (errors.length) logger.error(...errors);
+}
+function validateSet(node, isInline = false, { src }) {
+	const entry = {
+		group: "parser",
+		label: "resolver",
+		src
+	};
+	const errors = [];
+	let hasName = !isInline;
+	let hasType = !isInline;
+	let hasSources = false;
+	for (const member of node.members) {
+		if (member.name.type !== "String") continue;
+		switch (member.name.value) {
+			case "name":
+				hasName = true;
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				break;
+			case "description":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				break;
+			case "type":
+				hasType = true;
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				else if (member.value.value !== "set") errors.push({
+					...entry,
+					message: "\"type\" must be \"set\"."
+				});
+				break;
+			case "sources":
+				hasSources = true;
+				if (member.value.type !== "Array") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.ARRAY,
+					node: member.value
+				});
+				else if (member.value.elements.length === 0) errors.push({
+					...entry,
+					message: `"sources" can’t be empty array.`,
+					node: member.value
+				});
+				else for (const source of member.value.elements) if (source.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: source.value
+				});
+				break;
+			case "$defs":
+			case "$extensions":
+				if (member.value.type !== "Object") errors.push({
+					...entry,
+					message: `Expected object`,
+					node: member.value
+				});
+				break;
+			case "$ref":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: `Expected string`,
+					node: member.value
+				});
+				break;
+			default:
+				errors.push({
+					...entry,
+					message: `Unknown key ${JSON.stringify(member.name.value)}`,
+					node: member.name
+				});
+				break;
 		}
-	} });
-	resolveAliases(tokens, {
-		logger,
-		sources: sourceByFilename,
-		refMap
-	});
-	logger.debug({
-		...entry,
-		message: "Parsing: 2nd pass",
-		timing: performance.now() - secondPass
-	});
-	const aliasStart = performance.now();
-	graphAliases(refMap, {
-		tokens,
-		logger,
-		sources: sourceByFilename
-	});
-	logger.debug({
-		...entry,
-		message: "Alias graph built",
-		timing: performance.now() - aliasStart
-	});
-	const normalizeStart = performance.now();
-	for (const id of tokenIDs) {
-		const token = tokens[id];
-		normalize(token, {
-			logger,
-			src: sourceByFilename[token.source.filename]?.src
-		});
 	}
-	logger.debug({
+	if (!hasName) errors.push({
 		...entry,
-		message: "Normalized values",
-		timing: performance.now() - normalizeStart
+		message: `Missing "name".`,
+		node
 	});
-	const sortStart = performance.now();
-	const tokensSorted = {};
-	tokenIDs.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
-	for (const path of tokenIDs) {
-		const id = refToTokenID(path);
-		tokensSorted[id] = tokens[path];
-	}
-	for (const group of Object.values(groups)) group.tokens.sort((a, b) => a.localeCompare(b, "en-us", { numeric: true }));
-	logger.debug({
+	if (!hasType) errors.push({
 		...entry,
-		message: "Sorted tokens",
-		timing: performance.now() - sortStart
-	});
-	return tokensSorted;
-}
-
-//#endregion
-//#region src/resolver/normalize.ts
-/** Normalize resolver (assuming it’s been validated) */
-async function normalizeResolver(document, { logger, filename, req, src, yamlToMomoa }) {
-	const resolverBundle = await bundle([{
-		filename,
-		src
-	}], {
-		req,
-		yamlToMomoa
-	});
-	const resolverSource = momoa.evaluate(resolverBundle.document);
-	replaceNode(document, resolverBundle.document);
-	for (const set of Object.values(resolverSource.sets ?? {})) for (const source of set.sources) resolvePartials(source, {
-		resolver: resolverSource,
-		logger
-	});
-	for (const modifier of Object.values(resolverSource.modifiers ?? {})) for (const context of Object.values(modifier.contexts)) for (const source of context) resolvePartials(source, {
-		resolver: resolverSource,
-		logger
+		message: `"type": "set" missing.`,
+		node
 	});
-	for (const item of resolverSource.resolutionOrder ?? []) resolvePartials(item, {
-		resolver: resolverSource,
-		logger
+	if (!hasSources) errors.push({
+		...entry,
+		message: `Missing "sources".`,
+		node
 	});
-	return {
-		name: resolverSource.name,
-		version: resolverSource.version,
-		description: resolverSource.description,
-		sets: resolverSource.sets,
-		modifiers: resolverSource.modifiers,
-		resolutionOrder: resolverSource.resolutionOrder,
-		_source: {
-			filename,
-			document
-		}
-	};
+	return errors;
 }
-/** Resolve $refs for already-initialized JS */
-function resolvePartials(source, { resolver, logger }) {
-	if (!source) return;
+function validateModifier(node, isInline = false, { src }) {
+	const errors = [];
 	const entry = {
 		group: "parser",
-		label: "resolver"
+		label: "resolver",
+		src
 	};
-	if (Array.isArray(source)) for (const item of source) resolvePartials(item, {
-		resolver,
-		logger
-	});
-	else if (typeof source === "object") for (const k of Object.keys(source)) if (k === "$ref") {
-		const $ref = source[k];
-		const { url, subpath = [] } = parseRef($ref);
-		if (url !== "." || !subpath.length) logger.error({
-			...entry,
-			message: `Could not load $ref ${JSON.stringify($ref)}`
-		});
-		const found = findObject(resolver, subpath ?? [], logger);
-		if (subpath[0] === "sets" || subpath[0] === "modifiers") {
-			found.type = subpath[0].replace(/s$/, "");
-			found.name = subpath[1];
+	let hasName = !isInline;
+	let hasType = !isInline;
+	let hasContexts = false;
+	for (const member of node.members) {
+		if (member.name.type !== "String") continue;
+		switch (member.name.value) {
+			case "name":
+				hasName = true;
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				break;
+			case "description":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				break;
+			case "type":
+				hasType = true;
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.STRING,
+					node: member.value
+				});
+				else if (member.value.value !== "modifier") errors.push({
+					...entry,
+					message: "\"type\" must be \"modifier\"."
+				});
+				break;
+			case "contexts":
+				hasContexts = true;
+				if (member.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: member.value
+				});
+				else if (member.value.members.length === 0) errors.push({
+					...entry,
+					message: `"contexts" can’t be empty object.`,
+					node: member.value
+				});
+				else for (const context of member.value.members) if (context.value.type !== "Array") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.ARRAY,
+					node: context.value
+				});
+				else for (const source of context.value.elements) if (source.value.type !== "Object") errors.push({
+					...entry,
+					message: MESSAGE_EXPECTED.OBJECT,
+					node: source.value
+				});
+				break;
+			case "default":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: `Expected string`,
+					node: member.value
+				});
+				else {
+					const contexts = getObjMember(node, "contexts");
+					if (!contexts || !getObjMember(contexts, member.value.value)) errors.push({
+						...entry,
+						message: "Invalid default context",
+						node: member.value
+					});
+				}
+				break;
+			case "$defs":
+			case "$extensions":
+				if (member.value.type !== "Object") errors.push({
+					...entry,
+					message: `Expected object`,
+					node: member.value
+				});
+				break;
+			case "$ref":
+				if (member.value.type !== "String") errors.push({
+					...entry,
+					message: `Expected string`,
+					node: member.value
+				});
+				break;
+			default:
+				errors.push({
+					...entry,
+					message: `Unknown key ${JSON.stringify(member.name.value)}`,
+					node: member.name
+				});
+				break;
 		}
-		if (found) {
-			for (const k2 of Object.keys(found)) source[k2] = found[k2];
-			delete source.$ref;
-		} else logger.error({
-			...entry,
-			message: `Could not find ${JSON.stringify($ref)}`
-		});
-	} else resolvePartials(source[k], {
-		resolver,
-		logger
-	});
-}
-function findObject(dict, path, logger) {
-	let node = dict;
-	for (const idRaw of path) {
-		const id = idRaw.replace(/~/g, "~0").replace(/\//g, "~1");
-		if (!(id in node)) logger.error({
-			group: "parser",
-			label: "resolver",
-			message: `Could not load $ref ${encodeFragment(path)}`
-		});
-		node = node[id];
 	}
-	return node;
+	if (!hasName) errors.push({
+		...entry,
+		message: `Missing "name".`,
+		node
+	});
+	if (!hasType) errors.push({
+		...entry,
+		message: `"type": "modifier" missing.`,
+		node
+	});
+	if (!hasContexts) errors.push({
+		...entry,
+		message: `Missing "contexts".`,
+		node
+	});
+	return errors;
 }
 
 //#endregion
@@ -3687,8 +3731,8 @@ function createResolver(resolverSource, { config, logger, sources }) {
 				...inputDefaults,
 				...inputRaw
 			};
-			const inputKey = makeInputKey(input);
-			if (resolverCache[inputKey]) return resolverCache[inputKey];
+			const permutationID = getPermutationID(input);
+			if (resolverCache[permutationID]) return resolverCache[permutationID];
 			for (const item of resolverSource.resolutionOrder) switch (item.type) {
 				case "set":
 					for (const s of item.sources) tokensRaw = merge(tokensRaw, s);
@@ -3697,8 +3741,7 @@ function createResolver(resolverSource, { config, logger, sources }) {
 					const context = input[item.name];
 					const sources$1 = item.contexts[context];
 					if (!sources$1) logger.error({
-						group: "parser",
-						label: "resolver",
+						group: "resolver",
 						message: `Modifier ${item.name} has no context ${JSON.stringify(context)}.`
 					});
 					for (const s of sources$1 ?? []) tokensRaw = merge(tokensRaw, s);
@@ -3715,9 +3758,10 @@ function createResolver(resolverSource, { config, logger, sources }) {
 				config,
 				logger,
 				sourceByFilename: { [resolverSource._source.filename.href]: rootSource },
+				isResolver: true,
 				sources
 			});
-			resolverCache[inputKey] = tokens;
+			resolverCache[permutationID] = tokens;
 			return tokens;
 		},
 		source: resolverSource,
@@ -3725,17 +3769,41 @@ function createResolver(resolverSource, { config, logger, sources }) {
 			if (!allPermutations.length) allPermutations.push(...calculatePermutations(Object.entries(validContexts)));
 			return allPermutations;
 		},
-		isValidInput(input) {
+		isValidInput(input, throwError = false) {
 			if (!input || typeof input !== "object") logger.error({
-				group: "parser",
-				label: "resolver",
+				group: "resolver",
 				message: `Invalid input: ${JSON.stringify(input)}.`
 			});
-			if (!Object.keys(input).every((k) => k in validContexts)) return false;
+			for (const k of Object.keys(input)) if (!(k in validContexts)) {
+				if (throwError) logger.error({
+					group: "resolver",
+					message: `No such modifier ${JSON.stringify(k)}`
+				});
+				return false;
+			}
 			for (const [name, contexts] of Object.entries(validContexts)) if (name in input) {
-				if (!contexts.includes(input[name])) return false;
-			} else if (!(name in inputDefaults)) return false;
+				if (!contexts.includes(input[name])) {
+					if (throwError) logger.error({
+						group: "resolver",
+						message: `Modifier "${name}" has no context ${JSON.stringify(input[name])}.`
+					});
+					return false;
+				}
+			} else if (!(name in inputDefaults)) {
+				if (throwError) logger.error({
+					group: "resolver",
+					message: `Modifier "${name}" missing value (no default set).`
+				});
+				return false;
+			}
 			return true;
+		},
+		getPermutationID(input) {
+			this.isValidInput(input, true);
+			return getPermutationID({
+				...inputDefaults,
+				...input
+			});
 		}
 	};
 }