sculpted 0.0.0 → 0.1.0

package/dist/vite.mjs

@@ -0,0 +1,2325 @@
+import { _ as markerClassForEditId, c as DEFAULT_OPEN_SOURCE_ENDPOINT, d as DEFAULT_TOKEN_WRITEBACK_ENDPOINT, f as DEFAULT_WRITEBACK_ENDPOINT, p as PANDA_INSPECTOR_EVENTS, u as DEFAULT_STYLE_MODULE_ENDPOINT } from "./protocol-BJm-xGHP.mjs";
+import { _ as hashSource, a as createStyleModuleSourcePatch, c as safeProjectSourcePath, d as trustedManifestFilePath, f as trustedTokenSourceFilePath, g as analyzePandaCssSource, h as createInlineCssSourcePatch, i as createStyleModuleDetachPatch, l as stripViteQuery, m as createStaticCssPatch, n as componentStyleModulePaths, o as readComponentStyleModule, p as createStaticCssBatchPatch, r as createStyleModuleAttachPatch, s as normalizePath$1, t as createTokenConfigPatch, u as toRelativeProjectPath$1, x as resolveSourceParserAdapter, y as parsePandaSource } from "./patcher-BAw2kF1Q.mjs";
+import ts from "typescript";
+import { dirname } from "node:path";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { loadConfigAndCreateContext } from "@pandacss/node";
+//#region src/vite/constants.ts
+const DEFAULT_EXCLUDE = ["node_modules/**", "styled-system/**"];
+const DEFAULT_RUNTIME_BOOTSTRAP_ENDPOINT = "/@panda-inspector/runtime";
+const DEFAULT_RUNTIME_MODULE_ENDPOINT = "/@panda-inspector/runtime-module";
+const DEFAULT_UI_MODULE_ENDPOINT = "/@panda-inspector/ui-module";
+const DEFAULT_RUNTIME_CHUNK_ENDPOINT = "/@panda-inspector/runtime-chunks/";
+const DEFAULT_RUNTIME_MODULE_SOURCE_MAP_ENDPOINT = `${DEFAULT_RUNTIME_MODULE_ENDPOINT}.map`;
+const DEFAULT_UI_MODULE_SOURCE_MAP_ENDPOINT = `${DEFAULT_UI_MODULE_ENDPOINT}.map`;
+const DEFAULT_PANDA_CONFIG_FILES = [
+	"panda.config.ts",
+	"panda.config.mts",
+	"panda.config.js",
+	"panda.config.mjs",
+	"panda.config.cjs"
+];
+//#endregion
+//#region src/vite/editorProperties.ts
+function editorProperty(name, label, category, cssProperty, aliases = [], tokenCategory) {
+	return {
+		name,
+		label,
+		category,
+		cssProperty,
+		aliases,
+		tokenCategory,
+		defaultUnit: defaultEditorPropertyUnit(name, category)
+	};
+}
+function defaultEditorPropertyUnit(name, category) {
+	if ([
+		"zIndex",
+		"opacity",
+		"fontWeight",
+		"lineHeight",
+		"aspectRatio",
+		"order"
+	].includes(name)) return "";
+	if (name === "transitionDuration") return "ms";
+	if (category === "spacing" || category === "sizing" || [
+		"inset",
+		"top",
+		"right",
+		"bottom",
+		"left",
+		"fontSize",
+		"letterSpacing",
+		"flexBasis",
+		"borderWidth",
+		"borderRadius",
+		"borderTopRadius",
+		"borderRightRadius",
+		"borderBottomRadius",
+		"borderLeftRadius",
+		"borderTopWidth",
+		"borderRightWidth",
+		"borderBottomWidth",
+		"borderLeftWidth",
+		"outlineWidth",
+		"outlineOffset"
+	].includes(name)) return "px";
+}
+const DEFAULT_EDITOR_PROPERTIES = [
+	editorProperty("display", "Display", "layout", "display"),
+	editorProperty("position", "Position", "layout", "position", ["pos"]),
+	editorProperty("overflow", "Overflow", "layout", "overflow"),
+	editorProperty("overflowX", "Overflow X", "layout", "overflow-x"),
+	editorProperty("overflowY", "Overflow Y", "layout", "overflow-y"),
+	editorProperty("visibility", "Visibility", "layout", "visibility"),
+	editorProperty("boxSizing", "Box sizing", "layout", "box-sizing"),
+	editorProperty("zIndex", "Z index", "layout", "z-index", [], "zIndex"),
+	editorProperty("inset", "Inset", "layout", "inset", [], "spacing"),
+	editorProperty("top", "Top", "layout", "top", [], "spacing"),
+	editorProperty("right", "Right", "layout", "right", [], "spacing"),
+	editorProperty("bottom", "Bottom", "layout", "bottom", [], "spacing"),
+	editorProperty("left", "Left", "layout", "left", [], "spacing"),
+	editorProperty("padding", "Padding", "spacing", "padding", ["p"], "spacing"),
+	editorProperty("paddingX", "Padding X", "spacing", "padding-inline", ["px"], "spacing"),
+	editorProperty("paddingY", "Padding Y", "spacing", "padding-block", ["py"], "spacing"),
+	editorProperty("paddingTop", "Padding top", "spacing", "padding-top", ["pt"], "spacing"),
+	editorProperty("paddingRight", "Padding right", "spacing", "padding-right", ["pr"], "spacing"),
+	editorProperty("paddingBottom", "Padding bottom", "spacing", "padding-bottom", ["pb"], "spacing"),
+	editorProperty("paddingLeft", "Padding left", "spacing", "padding-left", ["pl"], "spacing"),
+	editorProperty("margin", "Margin", "spacing", "margin", ["m"], "spacing"),
+	editorProperty("marginX", "Margin X", "spacing", "margin-inline", ["mx"], "spacing"),
+	editorProperty("marginY", "Margin Y", "spacing", "margin-block", ["my"], "spacing"),
+	editorProperty("marginTop", "Margin top", "spacing", "margin-top", ["mt"], "spacing"),
+	editorProperty("marginRight", "Margin right", "spacing", "margin-right", ["mr"], "spacing"),
+	editorProperty("marginBottom", "Margin bottom", "spacing", "margin-bottom", ["mb"], "spacing"),
+	editorProperty("marginLeft", "Margin left", "spacing", "margin-left", ["ml"], "spacing"),
+	editorProperty("gap", "Gap", "spacing", "gap", [], "spacing"),
+	editorProperty("rowGap", "Row gap", "spacing", "row-gap", [], "spacing"),
+	editorProperty("columnGap", "Column gap", "spacing", "column-gap", [], "spacing"),
+	editorProperty("width", "Width", "sizing", "width", ["w"], "sizes"),
+	editorProperty("height", "Height", "sizing", "height", ["h"], "sizes"),
+	editorProperty("minWidth", "Min width", "sizing", "min-width", ["minW"], "sizes"),
+	editorProperty("maxWidth", "Max width", "sizing", "max-width", ["maxW"], "sizes"),
+	editorProperty("minHeight", "Min height", "sizing", "min-height", ["minH"], "sizes"),
+	editorProperty("maxHeight", "Max height", "sizing", "max-height", ["maxH"], "sizes"),
+	editorProperty("aspectRatio", "Aspect ratio", "sizing", "aspect-ratio"),
+	editorProperty("fontFamily", "Font family", "typography", "font-family", [], "fonts"),
+	editorProperty("fontSize", "Font size", "typography", "font-size", [], "fontSizes"),
+	editorProperty("fontWeight", "Font weight", "typography", "font-weight", [], "fontWeights"),
+	editorProperty("lineHeight", "Line height", "typography", "line-height", [], "lineHeights"),
+	editorProperty("letterSpacing", "Letter spacing", "typography", "letter-spacing", [], "letterSpacings"),
+	editorProperty("textAlign", "Text align", "typography", "text-align"),
+	editorProperty("textDecoration", "Text decoration", "typography", "text-decoration"),
+	editorProperty("textTransform", "Text transform", "typography", "text-transform"),
+	editorProperty("whiteSpace", "White space", "typography", "white-space"),
+	editorProperty("wordBreak", "Word break", "typography", "word-break"),
+	editorProperty("overflowWrap", "Overflow wrap", "typography", "overflow-wrap"),
+	editorProperty("textOverflow", "Text overflow", "typography", "text-overflow"),
+	editorProperty("color", "Color", "color", "color", [], "colors"),
+	editorProperty("background", "Background", "color", "background", ["bg"], "colors"),
+	editorProperty("backgroundColor", "Background color", "color", "background-color", ["bgColor"], "colors"),
+	editorProperty("borderColor", "Border color", "color", "border-color", [
+		"borderTopColor",
+		"borderRightColor",
+		"borderBottomColor",
+		"borderLeftColor",
+		"borderXColor",
+		"borderYColor"
+	], "colors"),
+	editorProperty("outlineColor", "Outline color", "color", "outline-color", [], "colors"),
+	editorProperty("fill", "Fill", "color", "fill", [], "colors"),
+	editorProperty("stroke", "Stroke", "color", "stroke", [], "colors"),
+	editorProperty("caretColor", "Caret color", "color", "caret-color", [], "colors"),
+	editorProperty("accentColor", "Accent color", "color", "accent-color", [], "colors"),
+	editorProperty("flex", "Flex", "layout", "flex"),
+	editorProperty("flexBasis", "Flex basis", "layout", "flex-basis", [], "sizes"),
+	editorProperty("flexDirection", "Flex direction", "layout", "flex-direction"),
+	editorProperty("flexWrap", "Flex wrap", "layout", "flex-wrap"),
+	editorProperty("alignItems", "Align items", "layout", "align-items"),
+	editorProperty("alignContent", "Align content", "layout", "align-content"),
+	editorProperty("alignSelf", "Align self", "layout", "align-self"),
+	editorProperty("justifyContent", "Justify content", "layout", "justify-content"),
+	editorProperty("justifyItems", "Justify items", "layout", "justify-items"),
+	editorProperty("justifySelf", "Justify self", "layout", "justify-self"),
+	editorProperty("order", "Order", "layout", "order"),
+	editorProperty("gridTemplateColumns", "Grid template columns", "layout", "grid-template-columns"),
+	editorProperty("gridTemplateRows", "Grid template rows", "layout", "grid-template-rows"),
+	editorProperty("gridColumn", "Grid column", "layout", "grid-column"),
+	editorProperty("gridRow", "Grid row", "layout", "grid-row"),
+	editorProperty("gridAutoFlow", "Grid auto flow", "layout", "grid-auto-flow"),
+	editorProperty("gridAutoColumns", "Grid auto columns", "layout", "grid-auto-columns"),
+	editorProperty("gridAutoRows", "Grid auto rows", "layout", "grid-auto-rows"),
+	editorProperty("border", "Border", "border", "border"),
+	editorProperty("borderWidth", "Border width", "border", "border-width", [], "borderWidths"),
+	editorProperty("borderStyle", "Border style", "border", "border-style"),
+	editorProperty("borderRadius", "Border radius", "border", "border-radius", ["rounded"], "radii"),
+	editorProperty("cornerShape", "Corner shape", "border", "corner-shape"),
+	editorProperty("borderTopRadius", "Rounded top", "border", "border-start-start-radius", ["roundedTop"], "radii"),
+	editorProperty("borderRightRadius", "Rounded right", "border", "border-start-end-radius", ["roundedRight"], "radii"),
+	editorProperty("borderBottomRadius", "Rounded bottom", "border", "border-end-end-radius", ["roundedBottom"], "radii"),
+	editorProperty("borderLeftRadius", "Rounded left", "border", "border-end-start-radius", ["roundedLeft"], "radii"),
+	editorProperty("borderTopWidth", "Border top width", "border", "border-top-width", [], "borderWidths"),
+	editorProperty("borderRightWidth", "Border right width", "border", "border-right-width", [], "borderWidths"),
+	editorProperty("borderBottomWidth", "Border bottom width", "border", "border-bottom-width", [], "borderWidths"),
+	editorProperty("borderLeftWidth", "Border left width", "border", "border-left-width", [], "borderWidths"),
+	editorProperty("backgroundImage", "Background image", "other", "background-image", ["bgImage"]),
+	editorProperty("backgroundSize", "Background size", "other", "background-size", ["bgSize"]),
+	editorProperty("backgroundPosition", "Background position", "other", "background-position", ["bgPosition"]),
+	editorProperty("backgroundRepeat", "Background repeat", "other", "background-repeat", ["bgRepeat"]),
+	editorProperty("backgroundAttachment", "Background attachment", "other", "background-attachment", ["bgAttachment"]),
+	editorProperty("backgroundClip", "Background clip", "other", "background-clip", ["bgClip"]),
+	editorProperty("opacity", "Opacity", "effects", "opacity", [], "opacity"),
+	editorProperty("boxShadow", "Box shadow", "effects", "box-shadow", [], "shadows"),
+	editorProperty("outline", "Outline", "effects", "outline"),
+	editorProperty("outlineWidth", "Outline width", "effects", "outline-width"),
+	editorProperty("outlineStyle", "Outline style", "effects", "outline-style"),
+	editorProperty("outlineOffset", "Outline offset", "effects", "outline-offset"),
+	editorProperty("transform", "Transform", "effects", "transform"),
+	editorProperty("filter", "Filter", "effects", "filter"),
+	editorProperty("backdropFilter", "Backdrop filter", "effects", "backdrop-filter"),
+	editorProperty("mixBlendMode", "Mix blend mode", "effects", "mix-blend-mode"),
+	editorProperty("cursor", "Cursor", "other", "cursor"),
+	editorProperty("pointerEvents", "Pointer events", "other", "pointer-events"),
+	editorProperty("userSelect", "User select", "other", "user-select"),
+	editorProperty("resize", "Resize", "other", "resize"),
+	editorProperty("scrollBehavior", "Scroll behavior", "other", "scroll-behavior"),
+	editorProperty("transition", "Transition", "other", "transition"),
+	editorProperty("transitionProperty", "Transition property", "other", "transition-property"),
+	editorProperty("transitionDuration", "Transition duration", "other", "transition-duration"),
+	editorProperty("transitionTimingFunction", "Transition timing function", "other", "transition-timing-function")
+];
+//#endregion
+//#region src/vite/editorMetadata.ts
+async function createEditorMetadata(options) {
+	const config = await readPandaConfigSource(options.projectRoot, options.pandaConfigPath);
+	const properties = {
+		status: "available",
+		items: DEFAULT_EDITOR_PROPERTIES
+	};
+	if (!config.ok) {
+		const unavailable = unavailableMetadataSection(config.reason, config.message);
+		const unavailableFontTokens = unavailableMetadataSection(config.reason, config.message);
+		const unavailableSources = unavailableMetadataSection(config.reason, config.message);
+		return {
+			version: 1,
+			projectRoot: options.projectRoot,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			tokenSources: unavailableSources,
+			colorTokens: unavailable,
+			semanticColorTokens: unavailable,
+			fontTokens: unavailableFontTokens,
+			properties
+		};
+	}
+	const parsed = parsePandaConfigEditorMetadata({
+		projectRoot: options.projectRoot,
+		filePath: config.filePath,
+		sourceText: config.sourceText
+	});
+	const resolved = await resolvePandaConfigEditorMetadata({
+		projectRoot: options.projectRoot,
+		pandaConfigPath: options.pandaConfigPath
+	});
+	if (!parsed.ok) {
+		const unavailable = unavailableMetadataSection(parsed.reason, parsed.message);
+		if (resolved.ok) return {
+			version: 1,
+			projectRoot: options.projectRoot,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			tokenSources: {
+				status: "available",
+				items: parsed.tokenSources
+			},
+			colorTokens: {
+				status: "available",
+				items: resolved.colorTokens
+			},
+			semanticColorTokens: {
+				status: "available",
+				items: resolved.semanticColorTokens
+			},
+			fontTokens: {
+				status: "available",
+				items: resolved.fontTokens
+			},
+			properties
+		};
+		return {
+			version: 1,
+			projectRoot: options.projectRoot,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			tokenSources: {
+				status: "available",
+				items: parsed.tokenSources
+			},
+			colorTokens: unavailable,
+			semanticColorTokens: unavailable,
+			fontTokens: unavailableMetadataSection(parsed.reason, parsed.message),
+			properties
+		};
+	}
+	return {
+		version: 1,
+		projectRoot: options.projectRoot,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		tokenSources: {
+			status: "available",
+			items: parsed.tokenSources
+		},
+		colorTokens: {
+			status: "available",
+			items: mergeResolvedAndStaticColorTokens(resolved.ok ? resolved.colorTokens : [], parsed.colorTokens)
+		},
+		semanticColorTokens: {
+			status: "available",
+			items: mergeResolvedAndStaticColorTokens(resolved.ok ? resolved.semanticColorTokens : [], parsed.semanticColorTokens)
+		},
+		fontTokens: {
+			status: "available",
+			items: mergeResolvedAndStaticFontTokens(resolved.ok ? resolved.fontTokens : [], parsed.fontTokens)
+		},
+		properties
+	};
+}
+async function readPandaConfigSource(projectRoot, pandaConfigPath) {
+	const root = normalizePath(projectRoot).replace(/\/$/, "");
+	const candidates = pandaConfigPath ? [absoluteProjectPath(root, pandaConfigPath)] : DEFAULT_PANDA_CONFIG_FILES.map((fileName) => `${root}/${fileName}`);
+	for (const filePath of candidates) try {
+		return {
+			ok: true,
+			filePath,
+			sourceText: await readFile(filePath, "utf8")
+		};
+	} catch (error) {
+		if (isMissingFileError$2(error)) continue;
+		return {
+			ok: false,
+			reason: "panda-config-unreadable",
+			message: `Failed to read Panda config ${filePath}: ${errorMessage(error)}`
+		};
+	}
+	return {
+		ok: false,
+		reason: "panda-config-missing",
+		message: pandaConfigPath ? `Panda config was not found at ${candidates[0]}.` : `No Panda config was found in ${root}.`
+	};
+}
+function parsePandaConfigEditorMetadata(options) {
+	const configObject = findPandaConfigObject(ts.createSourceFile(options.filePath, options.sourceText, ts.ScriptTarget.Latest, true));
+	if (!configObject) return {
+		ok: false,
+		reason: "unsupported-panda-config",
+		message: "Panda config metadata can only be read from a static object or defineConfig({ ... }) call.",
+		tokenSources: []
+	};
+	const theme = objectProperty(configObject, "theme");
+	const themeObject = theme ? objectLiteralExpression(theme) : void 0;
+	if (!themeObject) return {
+		ok: true,
+		tokenSources: [],
+		colorTokens: [],
+		semanticColorTokens: [],
+		fontTokens: []
+	};
+	const colorMetadata = collectThemeColorTokenMetadata({
+		projectRoot: options.projectRoot,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		themeObject,
+		section: "tokens",
+		kind: "token"
+	});
+	const semanticColorMetadata = collectThemeColorTokenMetadata({
+		projectRoot: options.projectRoot,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		themeObject,
+		section: "semanticTokens",
+		kind: "semantic-token"
+	});
+	const fontTokens = collectThemeFontTokenMetadata(themeObject);
+	return {
+		ok: true,
+		tokenSources: [...colorMetadata.tokenSources, ...semanticColorMetadata.tokenSources],
+		colorTokens: colorMetadata.tokens,
+		semanticColorTokens: semanticColorMetadata.tokens,
+		fontTokens
+	};
+}
+function collectThemeColorTokenMetadata(options) {
+	const directExpression = colorTokenExpressionForThemeSection(options.themeObject, options.section);
+	const direct = objectLiteralExpression(directExpression);
+	const extend = objectProperty(options.themeObject, "extend");
+	const extendedExpression = extend ? colorTokenExpressionForThemeSection(objectLiteralExpression(extend), options.section) : void 0;
+	const extended = objectLiteralExpression(extendedExpression);
+	const tokenSources = [];
+	const tokens = [];
+	if (direct) {
+		const sourceTarget = editorTokenSourceTarget({
+			projectRoot: options.projectRoot,
+			filePath: options.filePath,
+			sourceText: options.sourceText,
+			object: direct,
+			section: tokenSourceSection(options.section),
+			extended: false
+		});
+		tokenSources.push(sourceTarget);
+		tokens.push(...collectColorTokenMetadata(direct, {
+			kind: options.kind,
+			sourceTargetId: sourceTarget.id,
+			writable: sourceTarget.writable
+		}));
+	} else if (directExpression) tokenSources.push(editorReadOnlyTokenSourceTarget({
+		projectRoot: options.projectRoot,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		node: directExpression,
+		section: tokenSourceSection(options.section),
+		extended: false,
+		reason: "Token colors source is not a static object literal."
+	}));
+	if (extended) {
+		const sourceTarget = editorTokenSourceTarget({
+			projectRoot: options.projectRoot,
+			filePath: options.filePath,
+			sourceText: options.sourceText,
+			object: extended,
+			section: tokenSourceSection(options.section),
+			extended: true
+		});
+		tokenSources.push(sourceTarget);
+		tokens.push(...collectColorTokenMetadata(extended, {
+			kind: options.kind,
+			sourceTargetId: sourceTarget.id,
+			writable: sourceTarget.writable
+		}));
+	} else if (extendedExpression) tokenSources.push(editorReadOnlyTokenSourceTarget({
+		projectRoot: options.projectRoot,
+		filePath: options.filePath,
+		sourceText: options.sourceText,
+		node: extendedExpression,
+		section: tokenSourceSection(options.section),
+		extended: true,
+		reason: "Extended token colors source is not a static object literal."
+	}));
+	return {
+		tokenSources,
+		tokens
+	};
+}
+function colorTokenExpressionForThemeSection(themeObject, section) {
+	if (!themeObject) return void 0;
+	const tokenSection = objectProperty(themeObject, section);
+	const tokenSectionObject = tokenSection ? objectLiteralExpression(tokenSection) : void 0;
+	return tokenSectionObject ? objectProperty(tokenSectionObject, "colors") : void 0;
+}
+function tokenSourceSection(section) {
+	return section === "tokens" ? "tokens.colors" : "semanticTokens.colors";
+}
+function collectThemeFontTokenMetadata(themeObject) {
+	const tokens = [];
+	for (const expression of [fontTokenExpressionForThemeSection(themeObject), fontTokenExpressionForThemeSection(objectLiteralExpression(objectProperty(themeObject, "extend")))]) {
+		const object = objectLiteralExpression(expression);
+		if (!object) continue;
+		tokens.push(...collectFontTokenMetadata(object));
+	}
+	return tokens;
+}
+function fontTokenExpressionForThemeSection(themeObject) {
+	if (!themeObject) return void 0;
+	const tokens = objectLiteralExpression(objectProperty(themeObject, "tokens"));
+	return tokens ? objectProperty(tokens, "fonts") : void 0;
+}
+async function resolvePandaConfigEditorMetadata(options) {
+	try {
+		const context = await loadConfigAndCreateContext({
+			cwd: options.projectRoot,
+			configPath: options.pandaConfigPath ? absoluteProjectPath(options.projectRoot, options.pandaConfigPath) : void 0
+		});
+		const presetColorTokenOwners = presetColorTokenOwnersByKind(context.config.presets);
+		return {
+			ok: true,
+			colorTokens: resolvedTokenSpecColorMetadata(context.getSpecOfType("tokens"), "token", presetColorTokenOwners.token),
+			semanticColorTokens: resolvedTokenSpecColorMetadata(context.getSpecOfType("semantic-tokens"), "semantic-token", presetColorTokenOwners.semanticToken),
+			fontTokens: resolvedTokenSpecFontMetadata(context.getSpecOfType("tokens"), presetFontTokenOwners(context.config.presets))
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: `Failed to resolve Panda token metadata: ${errorMessage(error)}`
+		};
+	}
+}
+function resolvedTokenSpecFontMetadata(spec, presetOwners) {
+	if (!isRecord$3(spec) || !Array.isArray(spec.data)) return [];
+	const fontGroup = spec.data.find((group) => isRecord$3(group) && group.type === "fonts" && Array.isArray(group.values));
+	if (!fontGroup) return [];
+	return fontGroup.values.map((value) => resolvedFontTokenMetadata(value, presetOwners)).filter((value) => value !== void 0);
+}
+function resolvedFontTokenMetadata(value, presetOwners) {
+	if (!isRecord$3(value) || typeof value.name !== "string" || value.name.length === 0) return;
+	return {
+		kind: "token",
+		category: "fonts",
+		path: value.name,
+		label: value.name,
+		value: jsonValueFromUnknown(value.value),
+		cssVariable: typeof value.cssVar === "string" ? value.cssVar : void 0,
+		presetName: presetOwners.get(value.name)
+	};
+}
+function resolvedTokenSpecColorMetadata(spec, kind, presetOwners) {
+	if (!isRecord$3(spec) || !Array.isArray(spec.data)) return [];
+	const colorGroup = spec.data.find((group) => isRecord$3(group) && group.type === "colors" && Array.isArray(group.values));
+	if (!colorGroup) return [];
+	return colorGroup.values.map((value) => resolvedColorTokenMetadata(value, kind, presetOwners)).filter((value) => value !== void 0);
+}
+function resolvedColorTokenMetadata(value, kind, presetOwners) {
+	if (!isRecord$3(value) || typeof value.name !== "string" || value.name.length === 0) return;
+	if (kind === "semantic-token") {
+		const conditions = Array.isArray(value.values) ? value.values.flatMap((condition) => {
+			if (!isRecord$3(condition) || typeof condition.condition !== "string") return [];
+			const conditionValue = jsonValueFromUnknown(condition.value);
+			if (conditionValue === void 0) return [];
+			const swatch = swatchFromJsonValue(conditionValue);
+			return [swatch ? {
+				condition: condition.condition,
+				value: conditionValue,
+				swatch
+			} : {
+				condition: condition.condition,
+				value: conditionValue
+			}];
+		}) : void 0;
+		return {
+			kind,
+			category: "colors",
+			path: value.name,
+			label: value.name,
+			cssVariable: typeof value.cssVar === "string" ? value.cssVar : void 0,
+			presetName: presetOwners.get(value.name),
+			conditions,
+			writable: false,
+			readonlyReason: "Resolved Panda token metadata is read-only."
+		};
+	}
+	const tokenValue = jsonValueFromUnknown(value.value);
+	if (tokenValue === void 0) return void 0;
+	return {
+		kind,
+		category: "colors",
+		path: value.name,
+		label: value.name,
+		value: tokenValue,
+		swatch: swatchFromJsonValue(tokenValue),
+		cssVariable: typeof value.cssVar === "string" ? value.cssVar : void 0,
+		presetName: presetOwners.get(value.name),
+		writable: false,
+		readonlyReason: "Resolved Panda token metadata is read-only."
+	};
+}
+function presetColorTokenOwnersByKind(presets) {
+	const token = /* @__PURE__ */ new Map();
+	const semanticToken = /* @__PURE__ */ new Map();
+	if (!Array.isArray(presets)) return {
+		token,
+		semanticToken
+	};
+	for (const preset of presets) {
+		if (!isRecord$3(preset) || typeof preset.name !== "string") continue;
+		const theme = isRecord$3(preset.theme) ? preset.theme : void 0;
+		const tokens = isRecord$3(theme?.tokens) ? theme.tokens : void 0;
+		const semanticTokens = isRecord$3(theme?.semanticTokens) ? theme.semanticTokens : void 0;
+		collectPresetColorTokenOwners(tokens?.colors, preset.name, token);
+		collectPresetColorTokenOwners(semanticTokens?.colors, preset.name, semanticToken);
+	}
+	return {
+		token,
+		semanticToken
+	};
+}
+function collectPresetColorTokenOwners(value, presetName, owners, path = []) {
+	if (!isRecord$3(value)) return;
+	for (const [key, child] of Object.entries(value)) {
+		const nextPath = key === "DEFAULT" ? path : [...path, key];
+		if (!isRecord$3(child)) continue;
+		if ("value" in child && nextPath.length > 0) {
+			owners.set(nextPath.join("."), presetName);
+			continue;
+		}
+		collectPresetColorTokenOwners(child, presetName, owners, nextPath);
+	}
+}
+function presetFontTokenOwners(presets) {
+	const token = /* @__PURE__ */ new Map();
+	if (!Array.isArray(presets)) return token;
+	for (const preset of presets) {
+		if (!isRecord$3(preset) || typeof preset.name !== "string") continue;
+		const theme = isRecord$3(preset.theme) ? preset.theme : void 0;
+		collectPresetFontTokenOwners((isRecord$3(theme?.tokens) ? theme.tokens : void 0)?.fonts, preset.name, token);
+	}
+	return token;
+}
+function collectPresetFontTokenOwners(value, presetName, owners, path = []) {
+	if (!isRecord$3(value)) return;
+	for (const [key, child] of Object.entries(value)) {
+		const nextPath = key === "DEFAULT" ? path : [...path, key];
+		if (!isRecord$3(child)) continue;
+		if ("value" in child && nextPath.length > 0) {
+			owners.set(nextPath.join("."), presetName);
+			continue;
+		}
+		collectPresetFontTokenOwners(child, presetName, owners, nextPath);
+	}
+}
+function mergeResolvedAndStaticColorTokens(resolved, staticTokens) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const token of staticTokens) byKey.set(`${token.kind}:${token.path}`, token);
+	for (const token of resolved) {
+		const key = `${token.kind}:${token.path}`;
+		if (!byKey.has(key)) byKey.set(key, token);
+	}
+	return [...byKey.values()];
+}
+function mergeResolvedAndStaticFontTokens(resolved, staticTokens) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const token of staticTokens) byPath.set(token.path, token);
+	for (const token of resolved) if (!byPath.has(token.path)) byPath.set(token.path, token);
+	return [...byPath.values()];
+}
+function editorTokenSourceTarget(options) {
+	const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+	const rangeText = options.sourceText.slice(options.object.getStart(), options.object.getEnd());
+	const safety = tokenObjectWriteSafety(options.object);
+	const sourcePathPrefix = options.extended ? "theme.extend" : "theme";
+	return {
+		id: [
+			file,
+			sourcePathPrefix,
+			options.section,
+			options.object.getStart(),
+			options.object.getEnd()
+		].join("#"),
+		kind: "panda-config",
+		file,
+		absoluteFile: options.filePath,
+		range: {
+			start: options.object.getStart(),
+			end: options.object.getEnd()
+		},
+		sourceHash: hashSource(rangeText),
+		configPath: options.extended ? `${sourcePathPrefix}.${options.section}` : `${sourcePathPrefix}.${options.section}`,
+		writableSections: safety.writable ? [options.section] : [],
+		confidence: safety.writable ? "high" : "low",
+		writable: safety.writable,
+		readonlyReason: safety.writable ? void 0 : safety.reason
+	};
+}
+function editorReadOnlyTokenSourceTarget(options) {
+	const file = toRelativeProjectPath(options.filePath, options.projectRoot);
+	const rangeText = options.sourceText.slice(options.node.getStart(), options.node.getEnd());
+	const sourcePathPrefix = options.extended ? "theme.extend" : "theme";
+	return {
+		id: [
+			file,
+			sourcePathPrefix,
+			options.section,
+			options.node.getStart(),
+			options.node.getEnd()
+		].join("#"),
+		kind: "panda-config",
+		file,
+		absoluteFile: options.filePath,
+		range: {
+			start: options.node.getStart(),
+			end: options.node.getEnd()
+		},
+		sourceHash: hashSource(rangeText),
+		configPath: `${sourcePathPrefix}.${options.section}`,
+		writableSections: [],
+		confidence: "low",
+		writable: false,
+		readonlyReason: options.reason
+	};
+}
+function tokenObjectWriteSafety(object) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) return {
+			writable: false,
+			reason: "Token object contains a spread, shorthand, method, or accessor."
+		};
+		const key = propertyNameText(property.name);
+		if (!key) return {
+			writable: false,
+			reason: "Token object contains a computed key."
+		};
+		if (keys.has(key)) return {
+			writable: false,
+			reason: "Token object contains duplicate keys."
+		};
+		keys.add(key);
+		const valueObject = objectLiteralExpression(property.initializer);
+		if (!valueObject) return {
+			writable: false,
+			reason: "Token object contains a non-object token branch."
+		};
+		if (!objectProperty(valueObject, "value")) {
+			const nestedSafety = tokenObjectWriteSafety(valueObject);
+			if (!nestedSafety.writable) return nestedSafety;
+		}
+	}
+	return { writable: true };
+}
+function collectColorTokenMetadata(object, options, path = []) {
+	const tokens = [];
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		const key = propertyNameText(property.name);
+		if (!key) continue;
+		const valueObject = objectLiteralExpression(property.initializer);
+		if (!valueObject) continue;
+		const valueExpression = objectProperty(valueObject, "value");
+		const nextPath = key === "DEFAULT" ? path : [...path, key];
+		if (valueExpression) {
+			const value = jsonValueFromExpression(valueExpression);
+			if (value !== void 0 && nextPath.length > 0) {
+				const tokenPath = nextPath.join(".");
+				tokens.push({
+					kind: options.kind,
+					category: "colors",
+					path: tokenPath,
+					label: tokenPath,
+					value,
+					swatch: swatchFromJsonValue(value),
+					cssVariable: `var(--colors-${tokenPathToCssVariableSuffix(tokenPath)})`,
+					sourceTargetId: options.sourceTargetId,
+					sourcePath: nextPath,
+					writable: options.writable,
+					readonlyReason: options.writable ? void 0 : "Token source target is read-only.",
+					conditions: options.kind === "semantic-token" && isJsonObject(value) ? Object.entries(value).map(([condition, conditionValue]) => ({
+						condition,
+						value: conditionValue,
+						swatch: swatchFromJsonValue(conditionValue)
+					})) : void 0
+				});
+			}
+			continue;
+		}
+		tokens.push(...collectColorTokenMetadata(valueObject, options, nextPath));
+	}
+	return tokens;
+}
+function collectFontTokenMetadata(object, path = []) {
+	const tokens = [];
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		const key = propertyNameText(property.name);
+		if (!key) continue;
+		const valueObject = objectLiteralExpression(property.initializer);
+		if (!valueObject) continue;
+		const valueExpression = objectProperty(valueObject, "value");
+		const nextPath = key === "DEFAULT" ? path : [...path, key];
+		if (valueExpression) {
+			const value = jsonValueFromExpression(valueExpression);
+			if (value !== void 0 && nextPath.length > 0) {
+				const tokenPath = nextPath.join(".");
+				tokens.push({
+					kind: "token",
+					category: "fonts",
+					path: tokenPath,
+					label: tokenPath,
+					value,
+					cssVariable: `var(--fonts-${tokenPathToCssVariableSuffix(tokenPath)})`,
+					sourcePath: nextPath
+				});
+			}
+			continue;
+		}
+		tokens.push(...collectFontTokenMetadata(valueObject, nextPath));
+	}
+	return tokens;
+}
+function findPandaConfigObject(sourceFile) {
+	let result;
+	const visit = (node) => {
+		if (result) return;
+		if (ts.isExportAssignment(node)) {
+			result = configObjectFromExpression(node.expression);
+			if (result) return;
+		}
+		if (ts.isCallExpression(node) && callExpressionName(node.expression) === "defineConfig") {
+			result = objectLiteralExpression(node.arguments[0]);
+			if (result) return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return result;
+}
+function configObjectFromExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isObjectLiteralExpression(unwrapped)) return unwrapped;
+	if (ts.isCallExpression(unwrapped) && callExpressionName(unwrapped.expression) === "defineConfig") return objectLiteralExpression(unwrapped.arguments[0]);
+}
+function callExpressionName(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isIdentifier(unwrapped)) return unwrapped.text;
+	if (ts.isPropertyAccessExpression(unwrapped)) return unwrapped.name.text;
+}
+function objectProperty(object, name) {
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		if (propertyNameText(property.name) === name) return property.initializer;
+	}
+}
+function propertyNameText(name) {
+	if (ts.isIdentifier(name)) return name.text;
+	if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+}
+function objectLiteralExpression(expression) {
+	if (!expression) return void 0;
+	const unwrapped = unwrapExpression(expression);
+	return ts.isObjectLiteralExpression(unwrapped) ? unwrapped : void 0;
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	while (ts.isAsExpression(current) || ts.isSatisfiesExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+function jsonValueFromExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) return unwrapped.text;
+	if (ts.isNumericLiteral(unwrapped)) return Number(unwrapped.text);
+	if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (unwrapped.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isArrayLiteralExpression(unwrapped)) {
+		const items = unwrapped.elements.map((item) => jsonValueFromExpression(item));
+		return items.every((item) => item !== void 0) ? items : void 0;
+	}
+	if (ts.isObjectLiteralExpression(unwrapped)) {
+		const value = {};
+		for (const property of unwrapped.properties) {
+			if (!ts.isPropertyAssignment(property)) return void 0;
+			const key = propertyNameText(property.name);
+			if (!key) return void 0;
+			const propertyValue = jsonValueFromExpression(property.initializer);
+			if (propertyValue === void 0) return void 0;
+			value[key] = propertyValue;
+		}
+		return value;
+	}
+}
+function jsonValueFromUnknown(value) {
+	return isJsonValue$1(value) ? value : void 0;
+}
+function unavailableMetadataSection(reason, message) {
+	return {
+		status: "unavailable",
+		items: [],
+		reason,
+		message
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function swatchFromJsonValue(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (/^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(trimmed)) return trimmed;
+	if (/^(rgb|rgba|hsl|hsla|oklch|oklab|lch|lab|color)\(/i.test(trimmed)) return trimmed;
+}
+function tokenPathToCssVariableSuffix(value) {
+	return value.replace(/\./g, "-");
+}
+function absoluteProjectPath(projectRoot, filePath) {
+	const normalized = normalizePath(filePath);
+	if (normalized.startsWith("/")) return normalized;
+	return `${projectRoot}/${normalized.replace(/^\.\//, "")}`;
+}
+function toRelativeProjectPath(filePath, projectRoot) {
+	const file = normalizePath(filePath);
+	const root = normalizePath(projectRoot).replace(/\/$/, "");
+	return file.startsWith(`${root}/`) ? file.slice(root.length + 1) : file;
+}
+function normalizePath(path) {
+	return path.replace(/\\/g, "/");
+}
+function isMissingFileError$2(error) {
+	return isRecord$3(error) && error.code === "ENOENT";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonValue$1(value) {
+	if (value === null) return true;
+	if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value)) return true;
+	if (Array.isArray(value)) return value.every(isJsonValue$1);
+	if (!isRecord$3(value)) return false;
+	return Object.values(value).every(isJsonValue$1);
+}
+//#endregion
+//#region src/vite/sourceLocation.ts
+async function readOpenSourceLocationRequest(request) {
+	try {
+		const body = await readRequestBody$2(request);
+		const parsed = JSON.parse(body);
+		if (!isOpenSourceLocationRequest(parsed)) return {
+			ok: false,
+			response: openSourceLocationFailure("invalid-request", "Request body is not a valid source location request.")
+		};
+		return {
+			ok: true,
+			request: parsed
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			response: openSourceLocationFailure("invalid-request", `Failed to read source location request: ${error instanceof Error ? error.message : String(error)}`)
+		};
+	}
+}
+async function resolveOpenSourceLocation(options) {
+	const request = options.request;
+	if (request.kind === "component") {
+		const entry = options.manifest.entries.find((item) => item.id === request.editId);
+		if (!entry) return openSourceLocationFailure("missing-metadata", "No manifest entry exists for that component source location.");
+		const trustedPath = trustedManifestFilePath(options.manifest, entry);
+		if (!trustedPath.ok) return openSourceLocationFailure("path-outside-project", trustedPath.message, trustedPath.details);
+		const line = entry.loc?.start.line;
+		const column = entry.loc?.start.column;
+		try {
+			await access(trustedPath.file);
+		} catch {
+			return openSourceLocationFailure("file-not-found", "Component source file does not exist.", { file: toRelativeProjectPath$1(trustedPath.file, options.projectRoot) });
+		}
+		return openSourceLocationSuccess({
+			file: trustedPath.file,
+			line,
+			column,
+			projectRoot: options.projectRoot
+		});
+	}
+	const parsed = parseSourceLocationText(request.source);
+	if (!parsed.ok) return parsed.response;
+	const safePath = safeProjectSourcePath(options.projectRoot, parsed.file);
+	if (!safePath.ok) return openSourceLocationFailure(safePath.code, safePath.message, safePath.details);
+	try {
+		await access(safePath.file);
+	} catch {
+		return openSourceLocationFailure("file-not-found", "Source file does not exist.", { file: toRelativeProjectPath$1(safePath.file, options.projectRoot) });
+	}
+	return openSourceLocationSuccess({
+		file: safePath.file,
+		line: parsed.line,
+		column: parsed.column,
+		projectRoot: options.projectRoot
+	});
+}
+function parseSourceLocationText(source) {
+	const value = source.trim();
+	if (!value || /:\/\//.test(value)) return {
+		ok: false,
+		response: openSourceLocationFailure("invalid-request", "Source location must be a project file path.")
+	};
+	const match = /^(.*?)(?::(\d+)(?::(\d+))?)?$/.exec(value);
+	const file = match?.[1]?.trim();
+	if (!match || !file) return {
+		ok: false,
+		response: openSourceLocationFailure("invalid-request", "Source location must include a file path.")
+	};
+	const line = match[2] ? Number.parseInt(match[2], 10) : void 0;
+	const column = match[3] ? Number.parseInt(match[3], 10) : void 0;
+	if (line !== void 0 && line < 1 || column !== void 0 && column < 1) return {
+		ok: false,
+		response: openSourceLocationFailure("invalid-request", "Line and column numbers must be positive integers.")
+	};
+	return {
+		ok: true,
+		file,
+		line,
+		column
+	};
+}
+function openSourceLocationSuccess(options) {
+	const file = toRelativeProjectPath$1(options.file, options.projectRoot);
+	const location = [
+		options.file,
+		options.line === void 0 ? void 0 : String(options.line),
+		options.column === void 0 ? void 0 : String(options.column)
+	].filter((part) => part !== void 0).join(":");
+	return {
+		ok: true,
+		file,
+		line: options.line,
+		column: options.column,
+		openEditorUrl: `/__open-in-editor?file=${encodeURIComponent(location)}`
+	};
+}
+function openSourceLocationFailure(code, message, details) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+function isOpenSourceLocationRequest(value) {
+	if (!isRecord$2(value)) return false;
+	if (value.kind === "source") return typeof value.source === "string" && value.source.length > 0;
+	if (value.kind === "component") return typeof value.editId === "string" && value.editId.length > 0;
+	return false;
+}
+async function readRequestBody$2(request) {
+	if (!request[Symbol.asyncIterator]) return "";
+	let body = "";
+	for await (const chunk of request) body += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+	return body;
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/vite/runtimeModules.ts
+function registerRuntimeModuleRoutes(server, options) {
+	server.middlewares.use(options.runtimeBootstrapEndpoint, (_request, response) => {
+		response.statusCode = 200;
+		response.setHeader("content-type", "application/javascript");
+		response.setHeader("cache-control", "no-store");
+		response.end(runtimeBootstrapSource({
+			manifestEndpoint: options.manifestEndpoint,
+			editorMetadataEndpoint: options.editorMetadataEndpoint,
+			globalName: options.globalName,
+			runtimeModuleEndpoint: options.runtimeModuleEndpoint,
+			uiModuleEndpoint: options.uiModuleEndpoint
+		}));
+	});
+	server.middlewares.use(DEFAULT_RUNTIME_MODULE_SOURCE_MAP_ENDPOINT, async (_request, response) => {
+		try {
+			const runtimeModuleSourceMap = await readFile(new URL("./runtime.mjs.map", import.meta.url), "utf8");
+			response.statusCode = 200;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(runtimeModuleSourceMap);
+		} catch (error) {
+			response.statusCode = 404;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end(`Failed to load Panda inspector runtime module source map: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+	server.middlewares.use(options.runtimeModuleEndpoint, async (_request, response) => {
+		try {
+			const runtimeModuleSource = rewriteInspectorModuleSource(await readFile(new URL("./runtime.mjs", import.meta.url), "utf8"), options.runtimeChunkEndpoint, DEFAULT_RUNTIME_MODULE_SOURCE_MAP_ENDPOINT);
+			response.statusCode = 200;
+			response.setHeader("content-type", "application/javascript");
+			response.setHeader("cache-control", "no-store");
+			response.end(runtimeModuleSource);
+		} catch (error) {
+			response.statusCode = 500;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end(`Failed to load Panda inspector runtime module: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+	server.middlewares.use(options.runtimeChunkEndpoint, async (request, response) => {
+		const fileName = runtimeChunkFileName(request.url);
+		if (!fileName) {
+			response.statusCode = 404;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end("Unknown Panda inspector runtime chunk.");
+			return;
+		}
+		try {
+			const runtimeChunkSource = await readFile(new URL(`./${fileName}`, import.meta.url), "utf8");
+			response.statusCode = 200;
+			response.setHeader("content-type", fileName.endsWith(".map") ? "application/json" : "application/javascript");
+			response.setHeader("cache-control", "no-store");
+			response.end(runtimeChunkSource);
+		} catch (error) {
+			response.statusCode = 404;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end(`Failed to load Panda inspector runtime chunk: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+	server.middlewares.use(DEFAULT_UI_MODULE_SOURCE_MAP_ENDPOINT, async (_request, response) => {
+		try {
+			const uiModuleSourceMap = await readFile(new URL("./ui.mjs.map", import.meta.url), "utf8");
+			response.statusCode = 200;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(uiModuleSourceMap);
+		} catch (error) {
+			response.statusCode = 404;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end(`Failed to load Panda inspector UI module source map: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+	server.middlewares.use(options.uiModuleEndpoint, async (_request, response) => {
+		try {
+			const uiModuleSource = rewriteInspectorModuleSource(await readFile(new URL("./ui.mjs", import.meta.url), "utf8"), options.runtimeChunkEndpoint, DEFAULT_UI_MODULE_SOURCE_MAP_ENDPOINT);
+			response.statusCode = 200;
+			response.setHeader("content-type", "application/javascript");
+			response.setHeader("cache-control", "no-store");
+			response.end(uiModuleSource);
+		} catch (error) {
+			response.statusCode = 500;
+			response.setHeader("content-type", "text/plain");
+			response.setHeader("cache-control", "no-store");
+			response.end(`Failed to load Panda inspector UI module: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	});
+}
+function runtimeBootstrapSource(options) {
+	const runtimeOptions = JSON.stringify({
+		globalName: options.globalName,
+		manifestEndpoint: options.manifestEndpoint,
+		editorMetadataEndpoint: options.editorMetadataEndpoint
+	});
+	return [
+		`import { installPandaInspectorRuntime } from ${JSON.stringify(options.runtimeModuleEndpoint)};`,
+		`import { installReadonlyInspectorPanel } from ${JSON.stringify(options.uiModuleEndpoint)};`,
+		`const pandaInspectorRuntime = installPandaInspectorRuntime(${runtimeOptions});`,
+		"installReadonlyInspectorPanel(pandaInspectorRuntime);"
+	].join("\n");
+}
+function rewriteInspectorModuleSource(source, runtimeChunkEndpoint, sourceMapEndpoint) {
+	return source.replaceAll("from \"./", `from "${runtimeChunkEndpoint}`).replace(/\/\/# sourceMappingURL=[^\r\n]+/g, `//# sourceMappingURL=${sourceMapEndpoint}`);
+}
+function runtimeChunkFileName(url) {
+	const fileName = (url ?? "").replace(/[?#].*$/, "").split("/").filter(Boolean).at(-1);
+	if (!fileName || !/^[A-Za-z0-9._-]+\.mjs(?:\.map)?$/.test(fileName)) return void 0;
+	return fileName;
+}
+//#endregion
+//#region src/vite/styleModuleEndpoint.ts
+function registerStyleModuleRoute(server, options) {
+	server.middlewares.use(options.endpoint, async (request, response) => {
+		if (request.method && request.method !== "POST") {
+			response.statusCode = 405;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(styleModuleFailure("invalid-edit", "Panda inspector style-module discovery requires POST.")));
+			return;
+		}
+		const requestResult = await readStyleModuleRequest(request);
+		if (!requestResult.ok) {
+			response.statusCode = 400;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(requestResult.response));
+			return;
+		}
+		const paths = componentStyleModulePaths({
+			projectRoot: options.projectRoot,
+			componentSource: requestResult.componentSource
+		});
+		if (!paths.ok) {
+			response.statusCode = 400;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(styleModuleFailure(paths.code, paths.message, paths.details)));
+			return;
+		}
+		let sourceText;
+		try {
+			sourceText = await readFile(paths.paths.styleFile, "utf8");
+		} catch (error) {
+			if (!isMissingFileError$1(error)) {
+				response.statusCode = 400;
+				response.setHeader("content-type", "application/json");
+				response.setHeader("cache-control", "no-store");
+				response.end(JSON.stringify(styleModuleFailure("write-failed", `Failed to read style module: ${error instanceof Error ? error.message : String(error)}`)));
+				return;
+			}
+		}
+		const result = readComponentStyleModule({
+			projectRoot: options.projectRoot,
+			componentSource: requestResult.componentSource,
+			sourceText,
+			cssImportSources: options.cssImportSources
+		});
+		response.statusCode = result.ok ? 200 : 400;
+		response.setHeader("content-type", "application/json");
+		response.setHeader("cache-control", "no-store");
+		response.end(JSON.stringify(result));
+	});
+}
+async function readStyleModuleRequest(request) {
+	try {
+		const body = await readRequestBody$1(request);
+		const parsed = JSON.parse(body);
+		if (!isRecord$1(parsed) || typeof parsed.componentSource !== "string") return {
+			ok: false,
+			response: styleModuleFailure("invalid-edit", "Request body is not a valid style-module request.")
+		};
+		return {
+			ok: true,
+			componentSource: parsed.componentSource
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			response: styleModuleFailure("invalid-edit", `Failed to read style-module request: ${error instanceof Error ? error.message : String(error)}`)
+		};
+	}
+}
+async function readRequestBody$1(request) {
+	if (!request[Symbol.asyncIterator]) return "";
+	let body = "";
+	for await (const chunk of request) body += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+	return body;
+}
+function styleModuleFailure(code, message, details) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+function isMissingFileError$1(error) {
+	return isRecord$1(error) && error.code === "ENOENT";
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/vite/tsxInstrumentation.ts
+function transformTsxSource(options) {
+	const analysis = analyzePandaCssSource({
+		filePath: options.filePath,
+		projectRoot: options.projectRoot,
+		sourceText: options.sourceText,
+		cssImportSources: options.cssImportSources,
+		sourceSyntax: options.sourceSyntax
+	});
+	const source = parsePandaSource(options.sourceSyntax, {
+		filePath: options.filePath,
+		sourceText: options.sourceText
+	});
+	const targets = source.astKind === "typescript" ? findEditableJsxTargets(source.root, options.projectRoot) : [];
+	const jsxMetadataTargets = source.astKind === "typescript" ? findJsxMetadataTargets(source.root, options.projectRoot) : [];
+	const targetsByObjectStart = new Map(targets.map((target) => [target.objectStart, target]));
+	const cssCallTargets = findCssCallTargets(source);
+	const cssCallsByCallStart = new Map(cssCallTargets.map((target) => [target.callStart, target]));
+	const cssCallsByObjectStart = new Map(cssCallTargets.filter((target) => target.objectStart !== void 0).map((target) => [target.objectStart, target]));
+	const helperName = availableHelperName(options.sourceText);
+	const edits = [];
+	const entries = [];
+	const editableMetadataPositions = /* @__PURE__ */ new Set();
+	let needsHelper = false;
+	for (const entry of analysis.entries) {
+		const markerClass = markerClassForEditId(entry.id);
+		const target = entry.range ? targetsByObjectStart.get(entry.range.start) : void 0;
+		const nextEntry = {
+			...entry,
+			markerClass,
+			component: target?.component,
+			element: target?.element,
+			attribute: target?.attribute,
+			jsxSource: target?.jsxSource
+		};
+		entries.push(nextEntry);
+		const callTarget = entry.kind === "panda-css" && entry.range ? cssCallsByObjectStart.get(entry.range.start) : entry.range ? cssCallsByCallStart.get(entry.range.start) : void 0;
+		if (callTarget) {
+			edits.push({
+				position: callTarget.callStart,
+				text: `${helperName}(`
+			});
+			edits.push({
+				position: callTarget.callEnd,
+				text: `, ${JSON.stringify(markerClass)})`
+			});
+			needsHelper = true;
+		}
+		if (target) {
+			const attributeText = metadataAttributeText(nextEntry, target, options.attributes);
+			if (attributeText.length > 0) edits.push({
+				position: target.insertPosition,
+				text: attributeText
+			});
+			editableMetadataPositions.add(target.insertPosition);
+		}
+	}
+	for (const target of jsxMetadataTargets) {
+		if (editableMetadataPositions.has(target.insertPosition)) continue;
+		const attributeText = jsxMetadataAttributeText(target, options.attributes);
+		if (attributeText.length > 0) edits.push({
+			position: target.insertPosition,
+			text: attributeText
+		});
+	}
+	if (edits.length === 0) return {
+		code: options.sourceText,
+		entries
+	};
+	if (needsHelper) edits.push({
+		position: source.ops.firstImportEnd(source.root),
+		text: markerHelperSource(helperName)
+	});
+	let code = options.sourceText;
+	for (const edit of edits.sort((left, right) => right.position - left.position)) code = `${code.slice(0, edit.position)}${edit.text}${code.slice(edit.position)}`;
+	return {
+		code,
+		entries
+	};
+}
+function findCssCallTargets(source) {
+	const targets = [];
+	source.ops.walk(source.root, (node) => {
+		if (source.ops.isCallExpression(node)) {
+			const firstArg = source.ops.getCallArguments(node)[0];
+			const callRange = source.ops.getRange(node);
+			targets.push({
+				callStart: callRange.start,
+				callEnd: callRange.end,
+				objectStart: firstArg && source.ops.isObjectExpression(firstArg) ? source.ops.getRange(firstArg).start : void 0
+			});
+		}
+	});
+	return targets;
+}
+function availableHelperName(sourceText) {
+	const base = "__pandaInspectorClass";
+	if (!new RegExp(`\\b${base}\\b`).test(sourceText)) return base;
+	let index = 1;
+	while (new RegExp(`\\b${base}${index}\\b`).test(sourceText)) index += 1;
+	return `${base}${index}`;
+}
+function markerHelperSource(helperName) {
+	return [
+		"",
+		"",
+		`function ${helperName}(className, markerClass) {`,
+		"  return className ? `${className} ${markerClass}` : markerClass;",
+		"}",
+		""
+	].join("\n");
+}
+function findEditableJsxTargets(sourceFile, projectRoot) {
+	const targets = [];
+	const componentStack = [];
+	const visit = (node) => {
+		const component = componentNameForNode(node);
+		if (component) {
+			componentStack.push(component);
+			ts.forEachChild(node, visit);
+			componentStack.pop();
+			return;
+		}
+		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const target = targetForJsxElement(sourceFile, node, componentStack.at(-1), projectRoot);
+			if (target) targets.push(target);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return targets;
+}
+function findJsxMetadataTargets(sourceFile, projectRoot) {
+	const targets = [];
+	const componentStack = [];
+	const visit = (node) => {
+		const component = componentNameForNode(node);
+		if (component) {
+			componentStack.push(component);
+			ts.forEachChild(node, visit);
+			componentStack.pop();
+			return;
+		}
+		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const existingAttributes = /* @__PURE__ */ new Set();
+			for (const property of node.attributes.properties) if (ts.isJsxAttribute(property) && ts.isIdentifier(property.name)) existingAttributes.add(property.name.text);
+			targets.push({
+				insertPosition: node.getEnd() - (ts.isJsxSelfClosingElement(node) ? 2 : 1),
+				component: componentStack.at(-1),
+				jsxSource: sourceLocationText(sourceFile, node, projectRoot),
+				existingAttributes
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return targets;
+}
+function targetForJsxElement(sourceFile, node, component, projectRoot) {
+	const element = jsxTagNameText(node.tagName);
+	const existingAttributes = /* @__PURE__ */ new Set();
+	for (const property of node.attributes.properties) if (ts.isJsxAttribute(property) && ts.isIdentifier(property.name)) existingAttributes.add(property.name.text);
+	for (const property of node.attributes.properties) {
+		if (!ts.isJsxAttribute(property)) continue;
+		if (!ts.isIdentifier(property.name)) continue;
+		if (property.name.text !== "class" && property.name.text !== "className") continue;
+		const expression = property.initializer && jsxAttributeExpression(property.initializer);
+		if (!expression) continue;
+		const objectStart = firstCssObjectLiteralStart(sourceFile, expression);
+		if (objectStart === void 0) continue;
+		return {
+			objectStart,
+			insertPosition: node.getEnd() - (ts.isJsxSelfClosingElement(node) ? 2 : 1),
+			component,
+			jsxSource: sourceLocationText(sourceFile, node, projectRoot),
+			element,
+			attribute: property.name.text,
+			existingAttributes
+		};
+	}
+}
+function jsxAttributeExpression(initializer) {
+	if (ts.isJsxExpression(initializer)) return initializer.expression;
+}
+function sourceLocationText(sourceFile, node, projectRoot) {
+	const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return `${toRelativeProjectPath$1(sourceFile.fileName, projectRoot)}:${start.line + 1}:${start.character + 1}`;
+}
+function firstCssObjectLiteralStart(sourceFile, expression) {
+	let result;
+	const visit = (node) => {
+		if (result !== void 0) return;
+		if (ts.isCallExpression(node) && ts.isObjectLiteralExpression(node.arguments[0])) {
+			result = node.arguments[0].getStart(sourceFile);
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(expression);
+	return result;
+}
+function metadataAttributeText(entry, target, attributes) {
+	const source = entry.id.split("#")[0] ?? entry.id;
+	const metadata = [
+		[attributes.editId, entry.id],
+		[attributes.source, source],
+		[attributes.jsxSource, target.jsxSource],
+		[attributes.component, target.component]
+	];
+	let text = "";
+	for (const [name, value] of metadata) {
+		if (!value || target.existingAttributes.has(name)) continue;
+		text += ` ${name}="${escapeAttribute(value)}"`;
+	}
+	return text;
+}
+function jsxMetadataAttributeText(target, attributes) {
+	const metadata = [[attributes.jsxSource, target.jsxSource], [attributes.component, target.component]];
+	let text = "";
+	for (const [name, value] of metadata) {
+		if (!value || target.existingAttributes.has(name)) continue;
+		text += ` ${name}="${escapeAttribute(value)}"`;
+	}
+	return text;
+}
+function componentNameForNode(node) {
+	if (ts.isFunctionDeclaration(node) && node.name && isComponentName(node.name.text)) return node.name.text;
+	if (!ts.isVariableDeclaration(node)) return void 0;
+	if (!ts.isIdentifier(node.name) || !isComponentName(node.name.text)) return void 0;
+	if (!node.initializer) return void 0;
+	if (!ts.isArrowFunction(node.initializer) && !ts.isFunctionExpression(node.initializer)) return;
+	return node.name.text;
+}
+function jsxTagNameText(name) {
+	if (ts.isIdentifier(name)) return name.text;
+	if (ts.isPropertyAccessExpression(name)) return name.name.text;
+}
+function isComponentName(name) {
+	return /^[A-Z]/.test(name);
+}
+function shouldTransform(filePath, options) {
+	if (filePath.endsWith(".d.ts")) return false;
+	if (!resolveSourceParserAdapter(filePath, options.sourceSyntax).isSupportedFile(filePath)) return false;
+	if ([...DEFAULT_EXCLUDE, ...options.exclude ?? []].some((pattern) => matchesGlob(filePath, pattern))) return false;
+	if (!options.include || options.include.length === 0) return true;
+	return options.include.some((pattern) => matchesGlob(filePath, pattern));
+}
+function matchesGlob(filePath, pattern) {
+	const normalizedPattern = normalizePath$1(pattern);
+	let regex = "";
+	for (let index = 0; index < normalizedPattern.length; index += 1) {
+		const char = normalizedPattern[index];
+		const next = normalizedPattern[index + 1];
+		if (char === "*" && next === "*") {
+			if (normalizedPattern[index + 2] === "/") {
+				regex += "(?:.*/)?";
+				index += 2;
+				continue;
+			}
+			regex += ".*";
+			index += 1;
+			continue;
+		}
+		if (char === "*") {
+			regex += "[^/]*";
+			continue;
+		}
+		if (char === "{") {
+			const close = normalizedPattern.indexOf("}", index);
+			if (close !== -1) {
+				regex += `(${normalizedPattern.slice(index + 1, close).split(",").map(escapeRegExp).join("|")})`;
+				index = close;
+				continue;
+			}
+		}
+		regex += escapeRegExp(char);
+	}
+	return new RegExp(`(^|/)${regex}$`).test(filePath);
+}
+function escapeAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeRegExp(value) {
+	return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+//#endregion
+//#region src/vite/writebackEndpoints.ts
+function registerWritebackRoutes(server, options) {
+	server.middlewares.use(DEFAULT_WRITEBACK_ENDPOINT, async (request, response) => {
+		if (request.method && request.method !== "POST") {
+			response.statusCode = 405;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify({
+				ok: false,
+				editId: "",
+				written: false,
+				error: {
+					code: "invalid-edit",
+					message: "Panda inspector writeback requires POST."
+				}
+			}));
+			return;
+		}
+		const requestResult = await readStyleEditRequest(request);
+		if (!requestResult.ok) {
+			response.statusCode = 400;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(requestResult.response));
+			return;
+		}
+		const result = requestResult.request.kind === "panda-css-inline-source" ? await writeInlineCssSourcePatch({
+			request: requestResult.request,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources,
+			sourceSyntax: options.sourceSyntax,
+			attributes: options.attributes,
+			onManifestEntries: options.onManifestEntries
+		}) : requestResult.request.kind === "panda-css-style-module-source" || requestResult.request.kind === "panda-css-style-module-attach" || requestResult.request.kind === "panda-css-style-module-detach" ? await writeStyleModulePatch({
+			request: requestResult.request,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources,
+			styledSystemPackageName: await inferStyledSystemPackageName(options.projectRoot),
+			attributes: options.attributes,
+			onManifestEntries: options.onManifestEntries
+		}) : requestResult.request.kind === "panda-css-batch" ? await writeStaticCssBatchPatch({
+			manifest: options.manifest(),
+			request: requestResult.request,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources,
+			sourceSyntax: options.sourceSyntax,
+			onManifestEntries: options.onManifestEntries
+		}) : await writeStaticCssPatch({
+			manifest: options.manifest(),
+			request: requestResult.request,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources,
+			sourceSyntax: options.sourceSyntax,
+			onManifestEntries: options.onManifestEntries
+		});
+		response.statusCode = result.ok ? 200 : 400;
+		response.setHeader("content-type", "application/json");
+		response.setHeader("cache-control", "no-store");
+		response.end(JSON.stringify(result));
+		if (result.ok && result.written && result.manifestUpdate) {
+			notifyViteAboutWrittenFiles(server, options.projectRoot, result.manifestUpdate.changedFiles);
+			server.ws?.send(PANDA_INSPECTOR_EVENTS.manifestUpdate, result.manifestUpdate);
+		}
+	});
+	server.middlewares.use(DEFAULT_TOKEN_WRITEBACK_ENDPOINT, async (request, response) => {
+		if (request.method && request.method !== "POST") {
+			response.statusCode = 405;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(tokenConfigEditFailure("", "invalid-edit", "Panda inspector token writeback requires POST.")));
+			return;
+		}
+		const requestResult = await readTokenConfigEditRequest(request);
+		if (!requestResult.ok) {
+			response.statusCode = 400;
+			response.setHeader("content-type", "application/json");
+			response.setHeader("cache-control", "no-store");
+			response.end(JSON.stringify(requestResult.response));
+			return;
+		}
+		const result = await writeTokenConfigPatch({
+			request: requestResult.request,
+			projectRoot: options.projectRoot,
+			pandaConfigPath: options.pandaConfigPath
+		});
+		response.statusCode = result.ok ? 200 : 400;
+		response.setHeader("content-type", "application/json");
+		response.setHeader("cache-control", "no-store");
+		response.end(JSON.stringify(result));
+		if (result.ok && result.written && result.metadataUpdate) {
+			notifyViteAboutWrittenFiles(server, options.projectRoot, result.metadataUpdate.changedFiles);
+			server.ws?.send(PANDA_INSPECTOR_EVENTS.metadataUpdate, result.metadataUpdate);
+		}
+	});
+}
+function notifyViteAboutWrittenFiles(server, projectRoot, changedFiles) {
+	for (const changedFile of changedFiles) {
+		const absoluteFile = normalizePath$1(`${projectRoot.replace(/\/$/, "")}/${changedFile}`);
+		const modules = server.moduleGraph?.getModulesByFile?.(absoluteFile);
+		if (modules) for (const module of modules) server.moduleGraph?.invalidateModule?.(module);
+		server.watcher?.emit?.("change", absoluteFile);
+	}
+}
+async function readStyleEditRequest(request) {
+	try {
+		const body = await readRequestBody(request);
+		const parsed = JSON.parse(body);
+		if (!isStyleEditRequest(parsed) && !isStyleEditBatchRequest(parsed) && !isInlineCssSourceCreateRequest(parsed) && !isStyleModuleEditRequest(parsed)) return {
+			ok: false,
+			response: styleEditFailure("", "invalid-edit", "Request body is not a valid style edit request.")
+		};
+		return {
+			ok: true,
+			request: parsed
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			response: styleEditFailure("", "invalid-edit", `Failed to read style edit request: ${error instanceof Error ? error.message : String(error)}`)
+		};
+	}
+}
+async function readTokenConfigEditRequest(request) {
+	try {
+		const body = await readRequestBody(request);
+		const parsed = JSON.parse(body);
+		if (!isTokenConfigEditRequest(parsed)) return {
+			ok: false,
+			response: tokenConfigEditFailure("", "invalid-edit", "Request body is not a valid token config edit request.")
+		};
+		return {
+			ok: true,
+			request: parsed
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			response: tokenConfigEditFailure("", "invalid-edit", `Failed to read token config edit request: ${error instanceof Error ? error.message : String(error)}`)
+		};
+	}
+}
+async function readRequestBody(request) {
+	if (!request[Symbol.asyncIterator]) return "";
+	let body = "";
+	for await (const chunk of request) body += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+	return body;
+}
+function isStyleEditRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-css") return false;
+	if (!Array.isArray(value.edits) || value.edits.length === 0) return false;
+	return value.edits.every((edit) => {
+		if (!isRecord(edit)) return false;
+		if (edit.op === "set") return isPath(edit.path) && isJsonValue(edit.value);
+		if (edit.op === "delete") return isPath(edit.path);
+		if (edit.op === "rename") return isPath(edit.from) && isPath(edit.to);
+		if (edit.op === "replace-object") return isRecord(edit.value);
+		return false;
+	});
+}
+function isStyleEditBatchRequest(value) {
+	if (!isRecord(value)) return false;
+	if (value.kind !== "panda-css-batch") return false;
+	if (!Array.isArray(value.requests) || value.requests.length === 0) return false;
+	return value.requests.every(isStyleEditRequest);
+}
+function isInlineCssSourceCreateRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-css-inline-source") return false;
+	if (typeof value.jsxSource !== "string" || value.jsxSource.length === 0) return false;
+	return value.options === void 0 || isRecord(value.options);
+}
+function isStyleModuleEditRequest(value) {
+	return isStyleModuleSourceCreateRequest(value) || isStyleModuleSourceAttachRequest(value) || isStyleModuleSourceDetachRequest(value);
+}
+function isStyleModuleSourceCreateRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-css-style-module-source") return false;
+	if (typeof value.componentSource !== "string" || value.componentSource.length === 0) return false;
+	if (typeof value.name !== "string" || value.name.length === 0) return false;
+	if (value.edits !== void 0) {
+		if (!Array.isArray(value.edits)) return false;
+		if (!value.edits.every((edit) => {
+			if (!isRecord(edit)) return false;
+			if (edit.op === "set") return isPath(edit.path) && isJsonValue(edit.value);
+			if (edit.op === "delete") return isPath(edit.path);
+			return false;
+		})) return false;
+	}
+	return value.options === void 0 || isRecord(value.options);
+}
+function isStyleModuleSourceAttachRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-css-style-module-attach") return false;
+	if (typeof value.jsxSource !== "string" || value.jsxSource.length === 0) return false;
+	if (typeof value.componentSource !== "string" || value.componentSource.length === 0) return false;
+	if (typeof value.name !== "string" || value.name.length === 0) return false;
+	return value.options === void 0 || isRecord(value.options);
+}
+function isStyleModuleSourceDetachRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-css-style-module-detach") return false;
+	if (typeof value.jsxSource !== "string" || value.jsxSource.length === 0) return false;
+	if (typeof value.componentSource !== "string" || value.componentSource.length === 0) return false;
+	if (typeof value.name !== "string" || value.name.length === 0) return false;
+	return value.options === void 0 || isRecord(value.options);
+}
+function isTokenConfigEditRequest(value) {
+	if (!isRecord(value)) return false;
+	if (typeof value.editId !== "string" || value.editId.length === 0) return false;
+	if (value.kind !== "panda-token-config") return false;
+	if (typeof value.sourceTargetId !== "string" || value.sourceTargetId.length === 0) return false;
+	if (value.section !== "tokens.colors" && value.section !== "semanticTokens.colors") return false;
+	if (!isPath(value.path)) return false;
+	if (!isJsonPrimitive(value.value)) return false;
+	return value.options === void 0 || isRecord(value.options);
+}
+function styleEditBatchFailure(response) {
+	return {
+		ok: false,
+		editId: "",
+		responses: [response],
+		written: false,
+		error: response.error
+	};
+}
+function isNewEmptyInlineSourceEntry(entry) {
+	return entry.kind === "panda-css" && (entry.attribute === "class" || entry.attribute === "className") && Object.keys(entry.styleObject).length === 0;
+}
+async function writeInlineCssSourcePatch(options) {
+	const parsed = parseJsxSourceFile(options.request.jsxSource);
+	if (!parsed.ok) return styleEditFailure(options.request.editId, parsed.code, parsed.message, parsed.details);
+	const filePath = safeProjectSourcePath(options.projectRoot, parsed.file);
+	if (!filePath.ok) return styleEditFailure(options.request.editId, filePath.code, filePath.message, filePath.details);
+	let sourceText;
+	try {
+		sourceText = await readFile(filePath.file, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to read source file before inline source creation: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const patch = createInlineCssSourcePatch({
+		projectRoot: options.projectRoot,
+		request: {
+			...options.request,
+			options: {
+				...options.request.options,
+				write: true
+			}
+		},
+		sourceText,
+		filePath: filePath.file,
+		cssImportSources: options.cssImportSources,
+		sourceSyntax: options.sourceSyntax
+	});
+	if (!patch.ok || !patch.nextSource) return patch;
+	if (options.request.options?.write !== true) return patch;
+	try {
+		await writeFile(filePath.file, patch.nextSource, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to write source file: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const nextEntries = transformTsxSource({
+		sourceText: patch.nextSource,
+		filePath: filePath.file,
+		projectRoot: options.projectRoot,
+		attributes: options.attributes,
+		cssImportSources: options.cssImportSources,
+		sourceSyntax: options.sourceSyntax
+	}).entries.map((entry) => isNewEmptyInlineSourceEntry(entry) ? {
+		...entry,
+		jsxSourceAliases: Array.from(new Set([...entry.jsxSourceAliases ?? [], options.request.jsxSource]))
+	} : entry);
+	options.onManifestEntries(filePath.file, nextEntries);
+	const manifestUpdate = {
+		version: 1,
+		changedFiles: [toRelativeProjectPath$1(filePath.file, options.projectRoot)],
+		entryIds: nextEntries.map((nextEntry) => nextEntry.id)
+	};
+	return {
+		...patch,
+		written: true,
+		manifestUpdate
+	};
+}
+async function writeStyleModulePatch(options) {
+	const paths = componentStyleModulePaths({
+		projectRoot: options.projectRoot,
+		componentSource: options.request.componentSource
+	});
+	if (!paths.ok) return styleEditFailure(options.request.editId, paths.code, paths.message, paths.details);
+	const write = options.request.options?.write === true;
+	if (options.request.kind === "panda-css-style-module-source") {
+		let sourceText;
+		try {
+			sourceText = await readFile(paths.paths.styleFile, "utf8");
+		} catch (error) {
+			if (!isMissingFileError(error)) return styleEditFailure(options.request.editId, "write-failed", `Failed to read style module before writeback: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const patch = createStyleModuleSourcePatch({
+			projectRoot: options.projectRoot,
+			request: {
+				...options.request,
+				options: {
+					...options.request.options,
+					write
+				}
+			},
+			sourceText,
+			filePath: paths.paths.styleFile,
+			cssImportSources: options.cssImportSources
+		});
+		if (!patch.ok || !patch.nextSource) return patch;
+		if (!write) return patch;
+		try {
+			await mkdir(dirname(paths.paths.styleFile), { recursive: true });
+			await writeFile(paths.paths.styleFile, patch.nextSource, "utf8");
+		} catch (error) {
+			return styleEditFailure(options.request.editId, "write-failed", `Failed to write style module: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const nextEntries = analyzePandaCssSource({
+			sourceText: patch.nextSource,
+			filePath: paths.paths.styleFile,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources
+		}).entries;
+		options.onManifestEntries(paths.paths.styleFile, nextEntries);
+		const manifestUpdate = {
+			version: 1,
+			changedFiles: [paths.paths.styleFileRelative],
+			entryIds: nextEntries.map((nextEntry) => nextEntry.id)
+		};
+		return {
+			...patch,
+			written: true,
+			manifestUpdate
+		};
+	}
+	let componentSourceText;
+	try {
+		componentSourceText = await readFile(paths.paths.componentFile, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to read component module before style attachment: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	let styleSourceText;
+	try {
+		styleSourceText = await readFile(paths.paths.styleFile, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, isMissingFileError(error) ? "manifest-entry-not-found" : "write-failed", isMissingFileError(error) ? "Style module does not exist yet." : `Failed to read style module before attachment: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const patch = options.request.kind === "panda-css-style-module-attach" ? createStyleModuleAttachPatch({
+		projectRoot: options.projectRoot,
+		request: {
+			...options.request,
+			options: {
+				...options.request.options,
+				write
+			}
+		},
+		sourceText: componentSourceText,
+		filePath: paths.paths.componentFile,
+		styledSystemPackageName: options.styledSystemPackageName
+	}) : createStyleModuleDetachPatch({
+		projectRoot: options.projectRoot,
+		request: {
+			...options.request,
+			options: {
+				...options.request.options,
+				write
+			}
+		},
+		sourceText: componentSourceText,
+		filePath: paths.paths.componentFile
+	});
+	if (!patch.ok || !patch.nextSource) return patch;
+	if (!write) return patch;
+	try {
+		await writeFile(paths.paths.componentFile, patch.nextSource, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to write component module: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const componentEntries = transformTsxSource({
+		sourceText: patch.nextSource,
+		filePath: paths.paths.componentFile,
+		projectRoot: options.projectRoot,
+		attributes: options.attributes,
+		cssImportSources: options.cssImportSources
+	}).entries;
+	const analyzedStyleEntries = analyzePandaCssSource({
+		sourceText: styleSourceText,
+		filePath: paths.paths.styleFile,
+		projectRoot: options.projectRoot,
+		cssImportSources: options.cssImportSources
+	}).entries;
+	const styleEntries = styleModuleEntriesWithJsxAlias({
+		entries: analyzedStyleEntries,
+		request: options.request
+	});
+	options.onManifestEntries(paths.paths.componentFile, componentEntries);
+	options.onManifestEntries(paths.paths.styleFile, styleEntries);
+	const manifestUpdate = {
+		version: 1,
+		changedFiles: [toRelativeProjectPath$1(paths.paths.componentFile, options.projectRoot), paths.paths.styleFileRelative],
+		entryIds: [...componentEntries, ...styleEntries].map((nextEntry) => nextEntry.id)
+	};
+	return {
+		...patch,
+		written: true,
+		manifestUpdate
+	};
+}
+function styleModuleEntriesWithJsxAlias(options) {
+	return options.entries.map((entry) => {
+		if (entry.name !== options.request.name) return entry;
+		if (options.request.kind === "panda-css-style-module-attach") return {
+			...entry,
+			jsxSourceAliases: Array.from(new Set([...entry.jsxSourceAliases ?? [], options.request.jsxSource]))
+		};
+		const nextAliases = (entry.jsxSourceAliases ?? []).filter((source) => source !== options.request.jsxSource);
+		const { jsxSourceAliases: _removed, ...entryWithoutAliases } = entry;
+		return nextAliases.length === 0 ? entryWithoutAliases : {
+			...entry,
+			jsxSourceAliases: nextAliases
+		};
+	});
+}
+async function writeStaticCssPatch(options) {
+	const entry = options.manifest.entries.find((item) => item.id === options.request.editId);
+	if (!entry) return styleEditFailure(options.request.editId, "manifest-entry-not-found", "No manifest entry exists for edit id.");
+	const filePath = trustedManifestFilePath(options.manifest, entry);
+	if (!filePath.ok) return styleEditFailure(options.request.editId, filePath.code, filePath.message, filePath.details);
+	let sourceText;
+	try {
+		sourceText = await readFile(filePath.file, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to read source file before writeback: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const patch = createStaticCssPatch({
+		manifest: options.manifest,
+		request: {
+			...options.request,
+			options: {
+				...options.request.options,
+				write: true
+			}
+		},
+		sourceText,
+		filePath: filePath.file,
+		styledSystemPackageName: await inferStyledSystemPackageName(options.projectRoot),
+		sourceSyntax: options.sourceSyntax
+	});
+	if (!patch.ok || !patch.nextSource) return patch;
+	if (options.request.options?.write !== true) return patch;
+	try {
+		await writeFile(filePath.file, patch.nextSource, "utf8");
+	} catch (error) {
+		return styleEditFailure(options.request.editId, "write-failed", `Failed to write source file: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const nextEntries = analyzePandaCssSource({
+		sourceText: patch.nextSource,
+		filePath: filePath.file,
+		projectRoot: options.projectRoot,
+		cssImportSources: options.cssImportSources,
+		sourceSyntax: options.sourceSyntax
+	}).entries;
+	options.onManifestEntries(filePath.file, nextEntries);
+	const manifestUpdate = {
+		version: 1,
+		changedFiles: [toRelativeProjectPath$1(filePath.file, options.projectRoot)],
+		entryIds: nextEntries.map((nextEntry) => nextEntry.id)
+	};
+	return {
+		...patch,
+		written: true,
+		manifestUpdate
+	};
+}
+async function writeStaticCssBatchPatch(options) {
+	const write = options.request.options?.write === true;
+	const groups = /* @__PURE__ */ new Map();
+	for (const request of options.request.requests) {
+		const entry = options.manifest.entries.find((item) => item.id === request.editId);
+		if (!entry) return styleEditBatchFailure(styleEditFailure(request.editId, "manifest-entry-not-found", "No manifest entry exists for edit id."));
+		const filePath = trustedManifestFilePath(options.manifest, entry);
+		if (!filePath.ok) return styleEditBatchFailure(styleEditFailure(request.editId, filePath.code, filePath.message, filePath.details));
+		const changedFile = toRelativeProjectPath$1(filePath.file, options.projectRoot);
+		const group = groups.get(filePath.file);
+		if (group) group.requests.push(request);
+		else groups.set(filePath.file, {
+			file: filePath.file,
+			changedFile,
+			requests: [request]
+		});
+	}
+	const prepared = [];
+	for (const group of groups.values()) {
+		let sourceText;
+		try {
+			sourceText = await readFile(group.file, "utf8");
+		} catch (error) {
+			return styleEditBatchFailure(styleEditFailure(group.requests[0]?.editId ?? "", "write-failed", `Failed to read source file before writeback: ${error instanceof Error ? error.message : String(error)}`));
+		}
+		const patch = createStaticCssBatchPatch({
+			manifest: options.manifest,
+			requests: group.requests.map((request) => ({
+				...request,
+				options: {
+					...request.options,
+					write
+				}
+			})),
+			sourceText,
+			filePath: group.file,
+			styledSystemPackageName: await inferStyledSystemPackageName(options.projectRoot),
+			sourceSyntax: options.sourceSyntax
+		});
+		if (!patch.ok || !patch.nextSource) return styleEditBatchFailure(patch);
+		prepared.push({
+			file: group.file,
+			changedFile: group.changedFile,
+			requests: group.requests,
+			nextSource: patch.nextSource
+		});
+	}
+	const changedFiles = prepared.map((item) => item.changedFile);
+	const entryIds = [];
+	if (write) for (const item of prepared) {
+		try {
+			await writeFile(item.file, item.nextSource, "utf8");
+		} catch (error) {
+			return styleEditBatchFailure(styleEditFailure(item.requests[0]?.editId ?? "", "write-failed", `Failed to write source file: ${error instanceof Error ? error.message : String(error)}`));
+		}
+		const nextEntries = analyzePandaCssSource({
+			sourceText: item.nextSource,
+			filePath: item.file,
+			projectRoot: options.projectRoot,
+			cssImportSources: options.cssImportSources,
+			sourceSyntax: options.sourceSyntax
+		}).entries;
+		options.onManifestEntries(item.file, nextEntries);
+		entryIds.push(...nextEntries.map((nextEntry) => nextEntry.id));
+	}
+	const manifestUpdate = write ? {
+		version: 1,
+		changedFiles,
+		entryIds
+	} : void 0;
+	const fileByEditId = /* @__PURE__ */ new Map();
+	for (const item of prepared) for (const request of item.requests) fileByEditId.set(request.editId, item.changedFile);
+	return {
+		ok: true,
+		editId: "",
+		written: write,
+		manifestUpdate,
+		responses: options.request.requests.map((request) => ({
+			ok: true,
+			editId: request.editId,
+			file: fileByEditId.get(request.editId),
+			written: write,
+			manifestUpdate
+		}))
+	};
+}
+async function writeTokenConfigPatch(options) {
+	const metadata = await createEditorMetadata({
+		projectRoot: options.projectRoot,
+		pandaConfigPath: options.pandaConfigPath
+	});
+	if (metadata.tokenSources.status !== "available") return tokenConfigEditFailure(options.request.editId, "unsupported-source-shape", metadata.tokenSources.message);
+	const tokenSource = metadata.tokenSources.items.find((item) => item.id === options.request.sourceTargetId);
+	if (!tokenSource) return tokenConfigEditFailure(options.request.editId, "manifest-entry-not-found", "No token source exists for source target id.", { sourceTargetId: options.request.sourceTargetId });
+	const filePath = trustedTokenSourceFilePath(options.projectRoot, tokenSource);
+	if (!filePath.ok) return tokenConfigEditFailure(options.request.editId, filePath.code, filePath.message, filePath.details);
+	let sourceText;
+	try {
+		sourceText = await readFile(filePath.file, "utf8");
+	} catch (error) {
+		return tokenConfigEditFailure(options.request.editId, "write-failed", `Failed to read Panda config before token writeback: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const write = options.request.options?.write === true;
+	const patch = createTokenConfigPatch({
+		projectRoot: options.projectRoot,
+		tokenSource,
+		request: {
+			...options.request,
+			options: {
+				...options.request.options,
+				write
+			}
+		},
+		sourceText,
+		filePath: filePath.file
+	});
+	if (!patch.ok || !patch.nextSource) return patch;
+	if (!write) return patch;
+	try {
+		await writeFile(filePath.file, patch.nextSource, "utf8");
+	} catch (error) {
+		return tokenConfigEditFailure(options.request.editId, "write-failed", `Failed to write Panda config: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const nextMetadata = await createEditorMetadata({
+		projectRoot: options.projectRoot,
+		pandaConfigPath: options.pandaConfigPath
+	});
+	const metadataUpdate = {
+		version: 1,
+		changedFiles: [toRelativeProjectPath$1(filePath.file, options.projectRoot)],
+		tokenSourceIds: nextMetadata.tokenSources.status === "available" ? nextMetadata.tokenSources.items.map((item) => item.id) : []
+	};
+	return {
+		...patch,
+		written: true,
+		metadataUpdate
+	};
+}
+async function inferStyledSystemPackageName(projectRoot) {
+	try {
+		const packageText = await readFile(`${projectRoot.replace(/\/$/, "")}/styled-system/package.json`, "utf8");
+		const parsed = JSON.parse(packageText);
+		return typeof parsed.name === "string" && parsed.name.trim() ? parsed.name : void 0;
+	} catch {
+		return;
+	}
+}
+function styleEditFailure(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+function tokenConfigEditFailure(editId, code, message, details) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+function parseJsxSourceFile(source) {
+	const match = /^(.*):\d+:\d+$/.exec(source.trim());
+	const file = match?.[1]?.trim();
+	if (!match || !file) return {
+		ok: false,
+		code: "invalid-edit",
+		message: "Inline source creation requires a JSX source path with line and column.",
+		details: { source }
+	};
+	return {
+		ok: true,
+		file
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+	return isRecord(error) && error.code === "ENOENT";
+}
+function isPath(value) {
+	return Array.isArray(value) && value.every((part) => typeof part === "string" && part.length > 0);
+}
+function isJsonValue(value) {
+	if (value === null) return true;
+	if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value)) return true;
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	if (!isRecord(value)) return false;
+	return Object.values(value).every(isJsonValue);
+}
+function isJsonPrimitive(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+//#endregion
+//#region src/vite.ts
+function preactPandaInspector(options = {}) {
+	const manifestByFile = /* @__PURE__ */ new Map();
+	const endpoint = options.manifest?.virtualEndpoint ?? "/@panda-inspector/manifest";
+	const editorMetadataEndpoint = options.metadata?.virtualEndpoint ?? "/@panda-inspector/editor-metadata";
+	const runtimeBootstrapEndpoint = DEFAULT_RUNTIME_BOOTSTRAP_ENDPOINT;
+	const runtimeModuleEndpoint = DEFAULT_RUNTIME_MODULE_ENDPOINT;
+	const uiModuleEndpoint = DEFAULT_UI_MODULE_ENDPOINT;
+	const runtimeChunkEndpoint = DEFAULT_RUNTIME_CHUNK_ENDPOINT;
+	const attributes = {
+		editId: options.attributes?.editId ?? "data-panda-edit-id",
+		source: options.attributes?.source ?? "data-panda-source",
+		jsxSource: options.attributes?.jsxSource ?? "data-panda-jsx-source",
+		component: options.attributes?.component ?? "data-preact-component"
+	};
+	let projectRoot = normalizePath$1(options.projectRoot ?? "");
+	let devEnabled = options.enabled !== false;
+	let server;
+	const manifest = () => ({
+		version: 1,
+		projectRoot,
+		entries: [...manifestByFile.values()].flat()
+	});
+	return {
+		name: "preact-panda-inspector",
+		enforce: "pre",
+		configResolved(config) {
+			projectRoot = normalizePath$1(options.projectRoot ?? config.root ?? "");
+			devEnabled = options.enabled !== false && config.command !== "build" && config.mode !== "production";
+		},
+		configureServer(nextServer) {
+			server = nextServer;
+			if (!devEnabled) return;
+			nextServer.middlewares.use(endpoint, (_request, response) => {
+				response.statusCode = 200;
+				response.setHeader("content-type", "application/json");
+				response.setHeader("cache-control", "no-store");
+				response.end(JSON.stringify(manifest()));
+			});
+			nextServer.middlewares.use(editorMetadataEndpoint, async (_request, response) => {
+				const metadata = await createEditorMetadata({
+					projectRoot,
+					pandaConfigPath: options.panda?.configPath
+				});
+				response.statusCode = 200;
+				response.setHeader("content-type", "application/json");
+				response.setHeader("cache-control", "no-store");
+				response.end(JSON.stringify(metadata));
+			});
+			nextServer.middlewares.use(DEFAULT_OPEN_SOURCE_ENDPOINT, async (request, response) => {
+				if (request.method && request.method !== "POST") {
+					response.statusCode = 405;
+					response.setHeader("content-type", "application/json");
+					response.setHeader("cache-control", "no-store");
+					response.end(JSON.stringify(openSourceLocationFailure("invalid-request", "Panda inspector source opening requires POST.")));
+					return;
+				}
+				const requestResult = await readOpenSourceLocationRequest(request);
+				if (!requestResult.ok) {
+					response.statusCode = 400;
+					response.setHeader("content-type", "application/json");
+					response.setHeader("cache-control", "no-store");
+					response.end(JSON.stringify(requestResult.response));
+					return;
+				}
+				const result = await resolveOpenSourceLocation({
+					request: requestResult.request,
+					manifest: manifest(),
+					projectRoot
+				});
+				response.statusCode = result.ok ? 200 : 400;
+				response.setHeader("content-type", "application/json");
+				response.setHeader("cache-control", "no-store");
+				response.end(JSON.stringify(result));
+			});
+			registerWritebackRoutes(nextServer, {
+				projectRoot,
+				pandaConfigPath: options.panda?.configPath,
+				cssImportSources: options.panda?.cssImportSources,
+				sourceSyntax: options.sourceSyntax,
+				attributes,
+				manifest,
+				onManifestEntries(filePath, entries) {
+					manifestByFile.set(filePath, entries);
+				}
+			});
+			registerStyleModuleRoute(nextServer, {
+				endpoint: DEFAULT_STYLE_MODULE_ENDPOINT,
+				projectRoot,
+				cssImportSources: options.panda?.cssImportSources
+			});
+			registerRuntimeModuleRoutes(nextServer, {
+				manifestEndpoint: endpoint,
+				editorMetadataEndpoint,
+				globalName: options.runtime?.globalName,
+				runtimeBootstrapEndpoint,
+				runtimeModuleEndpoint,
+				uiModuleEndpoint,
+				runtimeChunkEndpoint
+			});
+		},
+		transformIndexHtml() {
+			if (!devEnabled || options.runtime?.inject === false) return void 0;
+			return [{
+				tag: "script",
+				attrs: {
+					type: "module",
+					src: runtimeBootstrapEndpoint
+				},
+				injectTo: "body"
+			}];
+		},
+		transform(code, id) {
+			const filePath = normalizePath$1(stripViteQuery(id));
+			if (!devEnabled || !shouldTransform(filePath, options)) {
+				manifestByFile.delete(filePath);
+				return null;
+			}
+			const result = transformTsxSource({
+				sourceText: code,
+				filePath,
+				projectRoot,
+				attributes,
+				cssImportSources: options.panda?.cssImportSources,
+				sourceSyntax: options.sourceSyntax
+			});
+			manifestByFile.set(filePath, result.entries);
+			if (result.entries.length > 0) server?.ws?.send(PANDA_INSPECTOR_EVENTS.manifestUpdate, {
+				version: 1,
+				changedFiles: [toRelativeProjectPath$1(filePath, projectRoot)],
+				entryIds: result.entries.map((entry) => entry.id)
+			});
+			if (result.code === code) return null;
+			return {
+				code: result.code,
+				map: null
+			};
+		}
+	};
+}
+//#endregion
+export { preactPandaInspector };