@vizejs/vite-plugin-musea 0.0.1-alpha.83 → 0.0.1-alpha.84

package/dist/index.d.ts

@@ -23,6 +23,9 @@ interface DesignToken {
   type?: string;
   description?: string;
   attributes?: Record<string, unknown>;
+  $tier?: "primitive" | "semantic";
+  $reference?: string;
+  $resolvedValue?: string | number;
 }
 /**
  * Token category (e.g., colors, spacing, typography).
@@ -74,6 +77,18 @@ type TokenTransform = (token: DesignToken, path: string[]) => DesignToken;
  * Parse Style Dictionary tokens file.
  */
 declare function parseTokens(tokensPath: string): Promise<TokenCategory[]>;
+/**
+ * Flatten nested categories into a flat map keyed by dot-path.
+ */
+declare function buildTokenMap(categories: TokenCategory[], prefix?: string[]): Record<string, DesignToken>;
+/**
+ * Resolve references in categories, setting $tier, $reference, and $resolvedValue.
+ */
+declare function resolveReferences(categories: TokenCategory[], tokenMap: Record<string, DesignToken>): void;
+/**
+ * Read raw JSON token file.
+ */
+
 /**
  * Generate HTML documentation for tokens.
  */
@@ -85,13 +100,44 @@ declare function generateTokensMarkdown(categories: TokenCategory[]): string;
 /**
  * Style Dictionary plugin for Musea.
  */
-declare function processStyleDictionary(config: StyleDictionaryConfig): Promise<StyleDictionaryOutput>; //#endregion
+declare function processStyleDictionary(config: StyleDictionaryConfig): Promise<StyleDictionaryOutput>;
+interface TokenUsageMatch {
+  line: number;
+  lineContent: string;
+  property: string;
+}
+interface TokenUsageEntry {
+  artPath: string;
+  artTitle: string;
+  artCategory?: string;
+  matches: TokenUsageMatch[];
+}
+type TokenUsageMap = Record<string, TokenUsageEntry[]>;
+/**
+ * Normalize a token value for comparison.
+ * - Lowercase, trim
+ * - Leading-zero: `.5rem` → `0.5rem`
+ * - Short hex: `#fff` → `#ffffff`
+ */
+
+/**
+ * Scan art file sources for token value matches in `<style>` blocks.
+ */
+declare function scanTokenUsage(artFiles: Map<string, {
+  path: string;
+  metadata: {
+    title: string;
+    category?: string;
+  };
+}>, tokenMap: Record<string, DesignToken>): TokenUsageMap; //#endregion
 //#region src/index.d.ts
+
+//# sourceMappingURL=style-dictionary.d.ts.map
 /**
  * Create Musea Vite plugin.
  */
 declare function musea(options?: MuseaOptions): Plugin[];
 
 //#endregion
-export { A11yOptions, A11yResult, A11ySummary, AnalysisApiResponse, ArtFileInfo, ArtMetadata, ArtVariant, AutogenOptions, AutogenOutput, CaptureConfig, CiConfig, ComparisonConfig, CsfOutput, DesignToken, GeneratedVariant, MuseaA11yRunner, MuseaOptions, MuseaTheme, MuseaThemeColors, MuseaVrtRunner, PaletteApiResponse, PropDefinition, StyleDictionaryConfig, StyleDictionaryOutput, TokenCategory, ViewportConfig, VrtOptions, VrtResult, VrtSummary, musea as default, generateArtFile, generateTokensHtml, generateTokensMarkdown, generateVrtJsonReport, generateVrtReport, musea, parseTokens, processStyleDictionary, writeArtFile };
+export { A11yOptions, A11yResult, A11ySummary, AnalysisApiResponse, ArtFileInfo, ArtMetadata, ArtVariant, AutogenOptions, AutogenOutput, CaptureConfig, CiConfig, ComparisonConfig, CsfOutput, DesignToken, GeneratedVariant, MuseaA11yRunner, MuseaOptions, MuseaTheme, MuseaThemeColors, MuseaVrtRunner, PaletteApiResponse, PropDefinition, StyleDictionaryConfig, StyleDictionaryOutput, TokenCategory, TokenUsageMap, ViewportConfig, VrtOptions, VrtResult, VrtSummary, buildTokenMap, musea as default, generateArtFile, generateTokensHtml, generateTokensMarkdown, generateVrtJsonReport, generateVrtReport, musea, parseTokens, processStyleDictionary, resolveReferences, scanTokenUsage, writeArtFile };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/style-dictionary.ts","../src/index.ts"],"sourcesContent":null,"mappings":";;;;;;;;;;;;;;;;;;;;UAWiB,WAAA;;;;eAIF;;AAJf;;;UAUiB,aAAA;EAAA,IAAA,EAAA,MAAA;EAAa,MAAA,EAEpB,MAFoB,CAAA,MAAA,EAEL,WAFK,CAAA;EAAA,aAEL,CAAA,EACP,aADO,EAAA;;;AACM;;UAMd,qBAAA;cACH;EADG,QAAA,EAAA;;;;EAYA,CAAA;;;;AA2BjB;AAA0B,UA3BT,qBAAA,CA2BS;EAAA;;AAAsD;;;;AAKhF;;EAAiC,YAA8B,CAAA,EAAA,MAAA,GAAA,MAAA,GAAA,UAAA;EAAa;AAAd;;;;EAgJ9C;;;eA3JD;AA6Rf;;;;AAsCsB,KA7TV,cAAA,GA6TgC,CAAA,KAAA,EA7TP,WA6TO,EAAA,IAAA,EAAA,MAAA,EAAA,EAAA,GA7TyB,WA6TzB;;;;AAEzC,iBA1TmB,WAAA,CA0TnB,UAAA,EAAA,MAAA,CAAA,EA1ToD,OA0TpD,CA1T4D,aA0T5D,EAAA,CAAA;AAAO;;;iBA1KM,kBAAA,aAA+B;;;;ACU/B,iBDwHA,sBAAA,CCxHK,UAAA,EDwH8B,aCxH9B,EAAA,CAAA,EAAA,MAAA;;;;AAAoC,iBD8JnC,sBAAA,CC9JmC,MAAA,ED+J/C,qBC/J+C,CAAA,EDgKtD,OChKsD,CDgK9C,qBChK8C,CAAA,CAAA;;AD5M1B;;;iBC4Mf,KAAA,WAAe,eAAoB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/style-dictionary.ts","../src/index.ts"],"sourcesContent":null,"mappings":";;;;;;;;;;;;;;;;;;;;UAWiB,WAAA;;;;eAIF;;EAJE,UAAA,CAAA,EAAA,MAAW;;;;AAa5B;;AAEyB,UAFR,aAAA,CAEQ;EAAW,IAA1B,EAAA,MAAA;EAAM,MACE,EADR,MACQ,CAAA,MAAA,EADO,WACP,CAAA;EAAa,aAAA,CAAA,EAAb,aAAa,EAAA;;;;AAM/B;UAAiB,qBAAA;cACH;;IAWG,IAAA,EAAA,MAAA;;;;AA2BjB;;;;AAAgF,UA3B/D,qBAAA,CA2B+D;;;;EAK1D,UAAA,EAAA,MAAW;EAAA;;;AAA6B;;;;AAuJ9D;;EAA6B,SACf,CAAA,EAAA,MAAA;EAAa;;AAElB;eArKM;;;AAkMf;;AACc,KA7LF,cAAA,GA6LE,CAAA,KAAA,EA7LuB,WA6LvB,EAAA,IAAA,EAAA,MAAA,EAAA,EAAA,GA7LuD,WA6LvD;;;AACI;iBAzLI,WAAA,sBAAiC,QAAQ;;;AAsY/D;iBA/OgB,aAAA,aACF,qCAEX,eAAe;;;AA8WlB;iBAjVgB,iBAAA,aACF,2BACF,eAAe;;;AAqX3B;;;;;iBAxKgB,kBAAA,aAA+B;ACjO/C;;;AAAmD,iBDmWnC,sBAAA,CCnWmC,UAAA,EDmWA,aCnWA,EAAA,CAAA,EAAA,MAAA;AAAM;;;iBDyYnC,sBAAA,SACZ,wBACP,QAAQ;UA6CM,eAAA;;;;;UAMA,eAAA;;;;WAIN;;KAGC,aAAA,GAAgB,eAAe;;;;;;;;;;;iBAgC3B,cAAA,WACJ;;;;;;cACA,eAAe,eACxB;;;;AA/rB4B;;;iBCuNf,KAAA,WAAe,eAAoB"}

package/dist/index.js

@@ -92,12 +92,15 @@ function isTokenValue(value) {
 * Normalize token to DesignToken interface.
 */
 function normalizeToken(raw) {
-	return {
+	const token = {
 		value: raw.value,
 		type: raw.type,
 		description: raw.description,
 		attributes: raw.attributes
 	};
+	if (raw.$tier === "primitive" || raw.$tier === "semantic") token.$tier = raw.$tier;
+	if (typeof raw.$reference === "string") token.$reference = raw.$reference;
+	return token;
 }
 /**
 * Format category name for display.
@@ -106,6 +109,168 @@ function formatCategoryName(name) {
 	return name.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
 /**
+* Flatten nested categories into a flat map keyed by dot-path.
+*/
+function buildTokenMap(categories, prefix = []) {
+	const map = {};
+	for (const cat of categories) {
+		const catKey = cat.name.toLowerCase().replace(/\s+/g, "-");
+		const catPath = [...prefix, catKey];
+		for (const [name, token] of Object.entries(cat.tokens)) {
+			const dotPath = [...catPath, name].join(".");
+			map[dotPath] = token;
+		}
+		if (cat.subcategories) {
+			const subMap = buildTokenMap(cat.subcategories, catPath);
+			Object.assign(map, subMap);
+		}
+	}
+	return map;
+}
+const REFERENCE_PATTERN = /^\{(.+)\}$/;
+const MAX_RESOLVE_DEPTH = 10;
+/**
+* Resolve references in categories, setting $tier, $reference, and $resolvedValue.
+*/
+function resolveReferences(categories, tokenMap) {
+	for (const cat of categories) {
+		for (const token of Object.values(cat.tokens)) resolveTokenReference(token, tokenMap);
+		if (cat.subcategories) resolveReferences(cat.subcategories, tokenMap);
+	}
+}
+function resolveTokenReference(token, tokenMap) {
+	if (typeof token.value === "string") {
+		const match = token.value.match(REFERENCE_PATTERN);
+		if (match) {
+			token.$tier = token.$tier ?? "semantic";
+			token.$reference = match[1];
+			token.$resolvedValue = resolveValue(match[1], tokenMap, 0, new Set());
+			return;
+		}
+	}
+	token.$tier = token.$tier ?? "primitive";
+}
+function resolveValue(ref, tokenMap, depth, visited) {
+	if (depth >= MAX_RESOLVE_DEPTH || visited.has(ref)) return void 0;
+	visited.add(ref);
+	const target = tokenMap[ref];
+	if (!target) return void 0;
+	if (typeof target.value === "string") {
+		const match = target.value.match(REFERENCE_PATTERN);
+		if (match) return resolveValue(match[1], tokenMap, depth + 1, visited);
+	}
+	return target.value;
+}
+/**
+* Read raw JSON token file.
+*/
+async function readRawTokenFile(tokensPath) {
+	const content = await fs.promises.readFile(tokensPath, "utf-8");
+	return JSON.parse(content);
+}
+/**
+* Write raw JSON token file atomically (write tmp, rename).
+*/
+async function writeRawTokenFile(tokensPath, data) {
+	const tmpPath = tokensPath + ".tmp";
+	await fs.promises.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	await fs.promises.rename(tmpPath, tokensPath);
+}
+/**
+* Set a token at a dot-separated path in the raw JSON structure.
+*/
+function setTokenAtPath(data, dotPath, token) {
+	const parts = dotPath.split(".");
+	let current = data;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const key = parts[i];
+		if (typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	const leafKey = parts[parts.length - 1];
+	const raw = { value: token.value };
+	if (token.type) raw.type = token.type;
+	if (token.description) raw.description = token.description;
+	if (token.$tier) raw.$tier = token.$tier;
+	if (token.$reference) raw.$reference = token.$reference;
+	if (token.attributes) raw.attributes = token.attributes;
+	current[leafKey] = raw;
+}
+/**
+* Delete a token at a dot-separated path, cleaning empty parents.
+*/
+function deleteTokenAtPath(data, dotPath) {
+	const parts = dotPath.split(".");
+	const parents = [];
+	let current = data;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const key = parts[i];
+		if (typeof current[key] !== "object" || current[key] === null) return false;
+		parents.push({
+			obj: current,
+			key
+		});
+		current = current[key];
+	}
+	const leafKey = parts[parts.length - 1];
+	if (!(leafKey in current)) return false;
+	delete current[leafKey];
+	for (let i = parents.length - 1; i >= 0; i--) {
+		const { obj, key } = parents[i];
+		const child = obj[key];
+		if (Object.keys(child).length === 0) delete obj[key];
+		else break;
+	}
+	return true;
+}
+/**
+* Validate that a semantic reference points to an existing token and has no cycles.
+*/
+function validateSemanticReference(tokenMap, reference, selfPath) {
+	if (!tokenMap[reference]) return {
+		valid: false,
+		error: `Reference target "${reference}" does not exist`
+	};
+	const visited = new Set();
+	if (selfPath) visited.add(selfPath);
+	let current = reference;
+	let depth = 0;
+	while (depth < MAX_RESOLVE_DEPTH) {
+		if (visited.has(current)) return {
+			valid: false,
+			error: `Circular reference detected at "${current}"`
+		};
+		visited.add(current);
+		const target = tokenMap[current];
+		if (!target) break;
+		if (typeof target.value === "string") {
+			const match = target.value.match(REFERENCE_PATTERN);
+			if (match) {
+				current = match[1];
+				depth++;
+				continue;
+			}
+		}
+		break;
+	}
+	if (depth >= MAX_RESOLVE_DEPTH) return {
+		valid: false,
+		error: "Reference chain too deep (max 10)"
+	};
+	return { valid: true };
+}
+/**
+* Find all tokens that reference the given path.
+*/
+function findDependentTokens(tokenMap, targetPath) {
+	const dependents = [];
+	for (const [path$1, token] of Object.entries(tokenMap)) if (typeof token.value === "string") {
+		const match = token.value.match(REFERENCE_PATTERN);
+		if (match && match[1] === targetPath) dependents.push(path$1);
+	}
+	return dependents;
+}
+/**
 * Generate HTML documentation for tokens.
 */
 function generateTokensHtml(categories) {
@@ -275,6 +440,97 @@ async function processStyleDictionary(config) {
 		}
 	};
 }
+/**
+* Normalize a token value for comparison.
+* - Lowercase, trim
+* - Leading-zero: `.5rem` → `0.5rem`
+* - Short hex: `#fff` → `#ffffff`
+*/
+function normalizeTokenValue(value) {
+	let v = String(value).trim().toLowerCase();
+	const shortHex = v.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/);
+	if (shortHex) {
+		const [, r, g, b, a] = shortHex;
+		v = a ? `#${r}${r}${g}${g}${b}${b}${a}${a}` : `#${r}${r}${g}${g}${b}${b}`;
+	}
+	v = v.replace(/(?<![0-9])\.(\d)/g, "0.$1");
+	return v;
+}
+const STYLE_BLOCK_RE = /<style[^>]*>([\s\S]*?)<\/style>/g;
+const CSS_PROPERTY_RE = /^\s*([\w-]+)\s*:\s*(.+?)\s*;?\s*$/;
+/**
+* Scan art file sources for token value matches in `<style>` blocks.
+*/
+function scanTokenUsage(artFiles, tokenMap) {
+	const valueLookup = new Map();
+	for (const [tokenPath, token] of Object.entries(tokenMap)) {
+		const rawValue = token.$resolvedValue ?? token.value;
+		const normalized = normalizeTokenValue(rawValue);
+		if (!normalized) continue;
+		const existing = valueLookup.get(normalized);
+		if (existing) existing.push(tokenPath);
+		else valueLookup.set(normalized, [tokenPath]);
+	}
+	const usageMap = {};
+	for (const [artPath, artInfo] of artFiles) {
+		let source;
+		try {
+			source = fs.readFileSync(artPath, "utf-8");
+		} catch {
+			continue;
+		}
+		const allLines = source.split("\n");
+		const styleRegions = [];
+		let match;
+		STYLE_BLOCK_RE.lastIndex = 0;
+		while ((match = STYLE_BLOCK_RE.exec(source)) !== null) {
+			const beforeMatch = source.slice(0, match.index);
+			const startTag = source.slice(match.index, match.index + match[0].indexOf(match[1]));
+			const startLine = beforeMatch.split("\n").length + startTag.split("\n").length - 1;
+			styleRegions.push({
+				startLine,
+				content: match[1]
+			});
+		}
+		for (const region of styleRegions) {
+			const lines = region.content.split("\n");
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				const propMatch = line.match(CSS_PROPERTY_RE);
+				if (!propMatch) continue;
+				const property = propMatch[1];
+				const valueStr = propMatch[2];
+				const valueParts = valueStr.split(/\s+/);
+				for (const part of valueParts) {
+					const normalizedPart = normalizeTokenValue(part);
+					const matchingTokens = valueLookup.get(normalizedPart);
+					if (!matchingTokens) continue;
+					const lineNumber = region.startLine + i;
+					const lineContent = allLines[lineNumber - 1]?.trim() ?? line.trim();
+					for (const tokenPath of matchingTokens) {
+						if (!usageMap[tokenPath]) usageMap[tokenPath] = [];
+						let entry = usageMap[tokenPath].find((e) => e.artPath === artPath);
+						if (!entry) {
+							entry = {
+								artPath,
+								artTitle: artInfo.metadata.title,
+								artCategory: artInfo.metadata.category,
+								matches: []
+							};
+							usageMap[tokenPath].push(entry);
+						}
+						if (!entry.matches.some((m) => m.line === lineNumber && m.property === property)) entry.matches.push({
+							line: lineNumber,
+							lineContent,
+							property
+						});
+					}
+				}
+			}
+		}
+	}
+	return usageMap;
+}
 
 //#endregion
 //#region src/index.ts
@@ -498,30 +754,263 @@ function musea(options = {}) {
 					sendJson(Array.from(artFiles.values()));
 					return;
 				}
+				if (req.url === "/tokens/usage" && req.method === "GET") {
+					if (!tokensPath) {
+						sendJson({});
+						return;
+					}
+					try {
+						const absoluteTokensPath = path.resolve(config.root, tokensPath);
+						const categories = await parseTokens(absoluteTokensPath);
+						const tokenMap = buildTokenMap(categories);
+						resolveReferences(categories, tokenMap);
+						const resolvedTokenMap = buildTokenMap(categories);
+						const usage = scanTokenUsage(artFiles, resolvedTokenMap);
+						sendJson(usage);
+					} catch (e) {
+						console.error("[musea] Failed to scan token usage:", e);
+						sendJson({});
+					}
+					return;
+				}
 				if (req.url === "/tokens" && req.method === "GET") {
 					if (!tokensPath) {
-						sendJson({ categories: [] });
+						sendJson({
+							categories: [],
+							tokenMap: {},
+							meta: {
+								filePath: "",
+								tokenCount: 0,
+								primitiveCount: 0,
+								semanticCount: 0
+							}
+						});
 						return;
 					}
 					try {
 						const absoluteTokensPath = path.resolve(config.root, tokensPath);
 						const categories = await parseTokens(absoluteTokensPath);
-						sendJson({ categories });
+						const tokenMap = buildTokenMap(categories);
+						resolveReferences(categories, tokenMap);
+						const resolvedTokenMap = buildTokenMap(categories);
+						let primitiveCount = 0;
+						let semanticCount = 0;
+						for (const token of Object.values(resolvedTokenMap)) if (token.$tier === "semantic") semanticCount++;
+						else primitiveCount++;
+						sendJson({
+							categories,
+							tokenMap: resolvedTokenMap,
+							meta: {
+								filePath: absoluteTokensPath,
+								tokenCount: Object.keys(resolvedTokenMap).length,
+								primitiveCount,
+								semanticCount
+							}
+						});
 					} catch (e) {
 						console.error("[musea] Failed to load tokens:", e);
 						sendJson({
 							categories: [],
+							tokenMap: {},
 							error: String(e)
 						});
 					}
 					return;
 				}
+				if (req.url === "/tokens" && req.method === "POST") {
+					if (!tokensPath) {
+						sendError("No tokens path configured", 400);
+						return;
+					}
+					let body = "";
+					req.on("data", (chunk) => {
+						body += chunk;
+					});
+					req.on("end", async () => {
+						try {
+							const { path: dotPath, token } = JSON.parse(body);
+							if (!dotPath || !token || token.value === void 0) {
+								sendError("Missing required fields: path, token.value", 400);
+								return;
+							}
+							const absoluteTokensPath = path.resolve(config.root, tokensPath);
+							const rawData = await readRawTokenFile(absoluteTokensPath);
+							const currentCategories = await parseTokens(absoluteTokensPath);
+							const currentMap = buildTokenMap(currentCategories);
+							if (currentMap[dotPath]) {
+								sendError(`Token already exists at path "${dotPath}"`, 409);
+								return;
+							}
+							if (token.$reference) {
+								const validation = validateSemanticReference(currentMap, token.$reference, dotPath);
+								if (!validation.valid) {
+									sendError(validation.error, 400);
+									return;
+								}
+								token.value = `{${token.$reference}}`;
+								token.$tier = "semantic";
+							}
+							setTokenAtPath(rawData, dotPath, token);
+							await writeRawTokenFile(absoluteTokensPath, rawData);
+							const categories = await parseTokens(absoluteTokensPath);
+							const tokenMap = buildTokenMap(categories);
+							resolveReferences(categories, tokenMap);
+							const resolvedTokenMap = buildTokenMap(categories);
+							sendJson({
+								categories,
+								tokenMap: resolvedTokenMap
+							}, 201);
+						} catch (e) {
+							sendError(e instanceof Error ? e.message : String(e));
+						}
+					});
+					return;
+				}
+				if (req.url === "/tokens" && req.method === "PUT") {
+					if (!tokensPath) {
+						sendError("No tokens path configured", 400);
+						return;
+					}
+					let body = "";
+					req.on("data", (chunk) => {
+						body += chunk;
+					});
+					req.on("end", async () => {
+						try {
+							const { path: dotPath, token } = JSON.parse(body);
+							if (!dotPath || !token || token.value === void 0) {
+								sendError("Missing required fields: path, token.value", 400);
+								return;
+							}
+							const absoluteTokensPath = path.resolve(config.root, tokensPath);
+							if (token.$reference) {
+								const currentCategories = await parseTokens(absoluteTokensPath);
+								const currentMap = buildTokenMap(currentCategories);
+								const validation = validateSemanticReference(currentMap, token.$reference, dotPath);
+								if (!validation.valid) {
+									sendError(validation.error, 400);
+									return;
+								}
+								token.value = `{${token.$reference}}`;
+								token.$tier = "semantic";
+							}
+							const rawData = await readRawTokenFile(absoluteTokensPath);
+							setTokenAtPath(rawData, dotPath, token);
+							await writeRawTokenFile(absoluteTokensPath, rawData);
+							const categories = await parseTokens(absoluteTokensPath);
+							const tokenMap = buildTokenMap(categories);
+							resolveReferences(categories, tokenMap);
+							const resolvedTokenMap = buildTokenMap(categories);
+							sendJson({
+								categories,
+								tokenMap: resolvedTokenMap
+							});
+						} catch (e) {
+							sendError(e instanceof Error ? e.message : String(e));
+						}
+					});
+					return;
+				}
+				if (req.url === "/tokens" && req.method === "DELETE") {
+					if (!tokensPath) {
+						sendError("No tokens path configured", 400);
+						return;
+					}
+					let body = "";
+					req.on("data", (chunk) => {
+						body += chunk;
+					});
+					req.on("end", async () => {
+						try {
+							const { path: dotPath } = JSON.parse(body);
+							if (!dotPath) {
+								sendError("Missing required field: path", 400);
+								return;
+							}
+							const absoluteTokensPath = path.resolve(config.root, tokensPath);
+							const currentCategories = await parseTokens(absoluteTokensPath);
+							const currentMap = buildTokenMap(currentCategories);
+							const dependents = findDependentTokens(currentMap, dotPath);
+							const rawData = await readRawTokenFile(absoluteTokensPath);
+							const deleted = deleteTokenAtPath(rawData, dotPath);
+							if (!deleted) {
+								sendError(`Token not found at path "${dotPath}"`, 404);
+								return;
+							}
+							await writeRawTokenFile(absoluteTokensPath, rawData);
+							const categories = await parseTokens(absoluteTokensPath);
+							const tokenMap = buildTokenMap(categories);
+							resolveReferences(categories, tokenMap);
+							const resolvedTokenMap = buildTokenMap(categories);
+							sendJson({
+								categories,
+								tokenMap: resolvedTokenMap,
+								dependentsWarning: dependents.length > 0 ? dependents : void 0
+							});
+						} catch (e) {
+							sendError(e instanceof Error ? e.message : String(e));
+						}
+					});
+					return;
+				}
+				if (req.url?.startsWith("/arts/") && req.method === "PUT") {
+					const rest = req.url.slice(6);
+					const sourceMatch = rest.match(/^(.+)\/source$/);
+					if (sourceMatch) {
+						const artPath = decodeURIComponent(sourceMatch[1]);
+						const art = artFiles.get(artPath);
+						if (!art) {
+							sendError("Art not found", 404);
+							return;
+						}
+						let body = "";
+						req.on("data", (chunk) => {
+							body += chunk;
+						});
+						req.on("end", async () => {
+							try {
+								const { source } = JSON.parse(body);
+								if (typeof source !== "string") {
+									sendError("Missing required field: source", 400);
+									return;
+								}
+								await fs.promises.writeFile(artPath, source, "utf-8");
+								await processArtFile(artPath);
+								sendJson({ success: true });
+							} catch (e) {
+								sendError(e instanceof Error ? e.message : String(e));
+							}
+						});
+						return;
+					}
+					next();
+					return;
+				}
 				if (req.url?.startsWith("/arts/") && req.method === "GET") {
 					const rest = req.url.slice(6);
+					const sourceMatch = rest.match(/^(.+)\/source$/);
 					const paletteMatch = rest.match(/^(.+)\/palette$/);
 					const analysisMatch = rest.match(/^(.+)\/analysis$/);
 					const docsMatch = rest.match(/^(.+)\/docs$/);
 					const a11yMatch = rest.match(/^(.+)\/variants\/([^/]+)\/a11y$/);
+					if (sourceMatch) {
+						const artPath$1 = decodeURIComponent(sourceMatch[1]);
+						const art$1 = artFiles.get(artPath$1);
+						if (!art$1) {
+							sendError("Art not found", 404);
+							return;
+						}
+						try {
+							const source = await fs.promises.readFile(artPath$1, "utf-8");
+							sendJson({
+								source,
+								path: artPath$1
+							});
+						} catch (e) {
+							sendError(e instanceof Error ? e.message : String(e));
+						}
+						return;
+					}
 					if (paletteMatch) {
 						const artPath$1 = decodeURIComponent(paletteMatch[1]);
 						const art$1 = artFiles.get(artPath$1);
@@ -2267,5 +2756,5 @@ function escapeHtml(str) {
 var src_default = musea;
 
 //#endregion
-export { MuseaA11yRunner, MuseaVrtRunner, src_default as default, generateArtFile, generateTokensHtml, generateTokensMarkdown, generateVrtJsonReport, generateVrtReport, musea, parseTokens, processStyleDictionary, writeArtFile };
+export { MuseaA11yRunner, MuseaVrtRunner, buildTokenMap, src_default as default, generateArtFile, generateTokensHtml, generateTokensMarkdown, generateVrtJsonReport, generateVrtReport, musea, parseTokens, processStyleDictionary, resolveReferences, scanTokenUsage, writeArtFile };
 //# sourceMappingURL=index.js.map