sculpted 0.3.2 → 0.3.3

package/dist/runtime.mjs

@@ -1,8 +1,374 @@
 import { _ as markerClassForEditId, g as editIdsFromMarkerClassList, r as DEFAULT_EDIT_ID_ATTRIBUTE } from "./protocol-D5heR2QM.mjs";
+import { z } from "zod";
+//#region src/shared/schemas.ts
+const StringArray = z.array(z.string());
+const SourcePosition = z.object({
+	line: z.number().int().min(1),
+	column: z.number().int().min(1)
+});
+const SourceLocation = z.object({
+	start: SourcePosition,
+	end: SourcePosition
+});
+const SourceRange = z.object({
+	start: z.number().int().min(0),
+	end: z.number().int().min(0)
+}).refine((range) => range.start <= range.end);
+const Confidence = z.enum([
+	"high",
+	"medium",
+	"low"
+]);
+const UnsupportedReason = z.enum([
+	"ambiguous-target",
+	"computed-css-only",
+	"dynamic-expression",
+	"external-class",
+	"generated-source",
+	"missing-source",
+	"multiple-targets",
+	"not-panda-css",
+	"spread-value",
+	"stale-metadata",
+	"unsupported-source-shape",
+	"variable-reference"
+]);
+const StyleValueSource = z.union([z.object({
+	kind: z.literal("literal"),
+	value: z.json(),
+	range: SourceRange.optional(),
+	loc: SourceLocation.optional()
+}), z.object({
+	kind: z.literal("unsupported"),
+	reason: UnsupportedReason,
+	description: z.string().optional(),
+	range: SourceRange.optional(),
+	loc: SourceLocation.optional()
+})]);
+const PandaStyleObject = z.lazy(() => z.record(z.string(), z.union([StyleValueSource, PandaStyleObject])));
+const SourceTargetBase = z.object({
+	id: z.string(),
+	file: z.string(),
+	absoluteFile: z.string().optional(),
+	range: SourceRange.optional(),
+	loc: SourceLocation.optional(),
+	sourceHash: z.string().optional(),
+	name: z.string().optional(),
+	component: z.string().optional(),
+	element: z.string().optional(),
+	attribute: z.string().optional(),
+	jsxSource: z.string().optional(),
+	jsxSourceAliases: StringArray.optional(),
+	markerClass: z.string().optional(),
+	confidence: Confidence,
+	reason: z.string().optional()
+});
+const InspectorManifestEntry = z.union([
+	SourceTargetBase.extend({
+		protocolVersion: z.number(),
+		kind: z.literal("panda-css"),
+		callee: z.string(),
+		styleObject: PandaStyleObject,
+		dynamic: z.literal(false)
+	}),
+	SourceTargetBase.extend({
+		protocolVersion: z.number(),
+		kind: z.literal("dynamic"),
+		dynamic: z.literal(true),
+		unsupportedReason: UnsupportedReason
+	}),
+	SourceTargetBase.extend({
+		protocolVersion: z.number(),
+		kind: z.literal("external"),
+		unsupportedReason: UnsupportedReason
+	}),
+	SourceTargetBase.extend({
+		protocolVersion: z.number(),
+		kind: z.literal("unsupported"),
+		unsupportedReason: UnsupportedReason
+	})
+]);
+const InspectorManifest = z.object({
+	version: z.number(),
+	projectRoot: z.string(),
+	generatedAt: z.string().optional(),
+	entries: z.array(InspectorManifestEntry)
+});
+const EditorMetadataUnavailableReason = z.enum([
+	"panda-config-missing",
+	"panda-config-unreadable",
+	"unsupported-panda-config",
+	"production-disabled"
+]);
+const EditorMetadataSection = (item) => z.union([z.object({
+	status: z.literal("available"),
+	items: z.array(item)
+}), z.object({
+	status: z.literal("unavailable"),
+	items: z.tuple([]),
+	reason: EditorMetadataUnavailableReason,
+	message: z.string()
+})]);
+const EditorTokenSourceSection = z.enum(["tokens.colors", "semanticTokens.colors"]);
+const EditorTokenSourceTarget = z.object({
+	id: z.string(),
+	kind: z.literal("panda-config"),
+	file: z.string(),
+	absoluteFile: z.string().optional(),
+	range: SourceRange.optional(),
+	sourceHash: z.string(),
+	configPath: z.string(),
+	writableSections: z.array(EditorTokenSourceSection),
+	confidence: Confidence,
+	writable: z.boolean(),
+	readonlyReason: z.string().optional()
+});
+const EditorTokenCondition = z.object({
+	condition: z.string(),
+	value: z.json(),
+	swatch: z.string().optional()
+});
+const EditorColorTokenMetadata = z.object({
+	kind: z.union([z.literal("token"), z.literal("semantic-token")]),
+	category: z.literal("colors"),
+	path: z.string(),
+	label: z.string(),
+	value: z.json().optional(),
+	swatch: z.string().optional(),
+	cssVariable: z.string().optional(),
+	presetName: z.string().optional(),
+	conditions: z.array(EditorTokenCondition).optional(),
+	sourceTargetId: z.string().optional(),
+	sourcePath: StringArray.optional(),
+	writable: z.boolean().optional(),
+	readonlyReason: z.string().optional()
+});
+const EditorFontTokenMetadata = z.object({
+	kind: z.literal("token"),
+	category: z.literal("fonts"),
+	path: z.string(),
+	label: z.string(),
+	value: z.json().optional(),
+	cssVariable: z.string().optional(),
+	presetName: z.string().optional(),
+	sourcePath: StringArray.optional()
+});
+const EditorPropertyCategory = z.enum([
+	"color",
+	"spacing",
+	"sizing",
+	"typography",
+	"layout",
+	"border",
+	"effects",
+	"other"
+]);
+const EditorPropertyMetadata = z.object({
+	name: z.string(),
+	label: z.string(),
+	category: EditorPropertyCategory,
+	cssProperty: z.string().optional(),
+	aliases: StringArray,
+	tokenCategory: z.string().optional(),
+	defaultUnit: z.string().optional()
+});
+const InspectorEditorMetadata = z.object({
+	version: z.number(),
+	projectRoot: z.string(),
+	generatedAt: z.string().optional(),
+	tokenSources: EditorMetadataSection(EditorTokenSourceTarget),
+	colorTokens: EditorMetadataSection(EditorColorTokenMetadata),
+	semanticColorTokens: EditorMetadataSection(EditorColorTokenMetadata),
+	fontTokens: EditorMetadataSection(EditorFontTokenMetadata).optional(),
+	properties: EditorMetadataSection(EditorPropertyMetadata)
+});
+const ManifestUpdate = z.object({
+	version: z.number(),
+	changedFiles: StringArray,
+	entryIds: StringArray
+});
+const EditorMetadataUpdate = z.object({
+	version: z.number(),
+	changedFiles: StringArray,
+	tokenSourceIds: StringArray
+});
+const StyleEditErrorCode = z.enum([
+	"ambiguous-target",
+	"invalid-edit",
+	"invalid-path",
+	"manifest-entry-not-found",
+	"parse-error",
+	"path-outside-project",
+	"production-disabled",
+	"stale-source",
+	"unsupported-operation",
+	"unsupported-source-shape",
+	"write-failed"
+]);
+const StyleEditError = z.object({
+	code: StyleEditErrorCode,
+	message: z.string(),
+	details: z.json().optional()
+});
+const StyleEditResponseBase = z.object({
+	ok: z.boolean(),
+	editId: z.string(),
+	file: z.string().optional(),
+	diff: z.string().optional(),
+	nextSource: z.string().optional(),
+	written: z.boolean().optional(),
+	manifestUpdate: ManifestUpdate.optional(),
+	warnings: StringArray.optional(),
+	error: StyleEditError.optional()
+});
+const StyleEditResponse = StyleEditResponseBase.superRefine((response, context) => {
+	if (response.ok && response.error !== void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Successful style edit responses must not include an error."
+	});
+	if (!response.ok && response.error === void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Failed style edit responses must include an error."
+	});
+});
+const TokenConfigEditResponse = StyleEditResponseBase.extend({ metadataUpdate: EditorMetadataUpdate.optional() }).superRefine((response, context) => {
+	if (response.ok && response.error !== void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Successful token config edit responses must not include an error."
+	});
+	if (!response.ok && response.error === void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Failed token config edit responses must include an error."
+	});
+});
+const StyleEditBatchResponse = z.object({
+	ok: z.boolean(),
+	editId: z.literal(""),
+	responses: z.array(StyleEditResponse),
+	written: z.boolean().optional(),
+	manifestUpdate: ManifestUpdate.optional(),
+	error: StyleEditError.optional()
+}).superRefine((response, context) => {
+	if (response.ok && response.error !== void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Successful batch responses must not include an error."
+	});
+	if (!response.ok && response.error === void 0) context.addIssue({
+		code: "custom",
+		path: ["error"],
+		message: "Failed batch responses must include an error."
+	});
+});
+const ComponentStyleModuleSource = z.object({
+	name: z.string(),
+	file: z.string(),
+	editId: z.string().optional(),
+	sourceHash: z.string().optional(),
+	styleObject: PandaStyleObject.optional()
+});
+const ComponentStyleModuleResponse = z.union([z.object({
+	ok: z.literal(true),
+	componentFile: z.string(),
+	styleFile: z.string(),
+	importPath: z.string(),
+	exists: z.boolean(),
+	sources: z.array(ComponentStyleModuleSource),
+	warnings: StringArray.optional(),
+	error: z.undefined().optional()
+}), z.object({
+	ok: z.literal(false),
+	error: StyleEditError
+})]);
+const OpenSourceLocationErrorCode = z.enum([
+	"invalid-request",
+	"missing-metadata",
+	"open-failed",
+	"path-outside-project",
+	"file-not-found"
+]);
+const OpenSourceLocationResponse = z.union([z.object({
+	ok: z.literal(true),
+	file: z.string(),
+	line: z.number().int().min(1).optional(),
+	column: z.number().int().min(1).optional(),
+	openEditorUrl: z.string().startsWith("/__open-in-editor?"),
+	error: z.undefined().optional()
+}), z.object({
+	ok: z.literal(false),
+	error: z.object({
+		code: OpenSourceLocationErrorCode,
+		message: z.string(),
+		details: z.json().optional()
+	})
+})]);
+function isInspectorManifest(value) {
+	return InspectorManifest.safeParse(value).success;
+}
+function isInspectorEditorMetadata(value) {
+	return InspectorEditorMetadata.safeParse(value).success;
+}
+function isStyleEditResponse(value) {
+	return StyleEditResponse.safeParse(value).success;
+}
+function isStyleEditResponseForEditId(value, expectedEditId) {
+	return isStyleEditResponse(value) && (expectedEditId === void 0 || value.editId === expectedEditId);
+}
+function isTokenConfigEditResponse(value, expectedEditId) {
+	const result = TokenConfigEditResponse.safeParse(value);
+	return result.success && (expectedEditId === void 0 || result.data.editId === expectedEditId);
+}
+function isStyleEditBatchResponse(value) {
+	return StyleEditBatchResponse.safeParse(value).success;
+}
+function isComponentStyleModuleResponse(value) {
+	return ComponentStyleModuleResponse.safeParse(value).success;
+}
+function isOpenSourceLocationResponse(value) {
+	return OpenSourceLocationResponse.safeParse(value).success;
+}
+//#endregion
 //#region src/runtime.ts
 const DEFAULT_GLOBAL_NAME = "__SCULPTED__";
 const PREVIEW_STYLE_ID = "sculpted-preview-styles";
 const HIGHLIGHT_ID = "sculpted-highlight";
+const INHERITED_CSS_PROPERTIES = [
+	"border-collapse",
+	"border-spacing",
+	"caption-side",
+	"color",
+	"cursor",
+	"direction",
+	"empty-cells",
+	"font-family",
+	"font-feature-settings",
+	"font-kerning",
+	"font-size",
+	"font-stretch",
+	"font-style",
+	"font-variant",
+	"font-variant-caps",
+	"font-weight",
+	"letter-spacing",
+	"line-height",
+	"list-style-image",
+	"list-style-position",
+	"list-style-type",
+	"quotes",
+	"tab-size",
+	"text-align",
+	"text-indent",
+	"text-rendering",
+	"text-transform",
+	"visibility",
+	"white-space",
+	"word-break",
+	"word-spacing"
+];
 var SculptedRuntime = class {
 	version = 1;
 	manifestEndpoint;
@@ -37,7 +403,9 @@ var SculptedRuntime = class {
 	async loadManifest() {
 		const response = await this.#environment.fetch(this.manifestEndpoint, { cache: "no-store" });
 		if (!response.ok) throw new Error(`Failed to load Sculpted manifest: ${response.status}`);
-		const manifest = await response.json();
+		const parsed = await responseJson(response);
+		if (!isInspectorManifest(parsed)) throw new Error(manifestLoadMessage(response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol"));
+		const manifest = parsed;
 		this.#manifest = manifest;
 		this.#entries = new Map(manifest.entries.map((entry) => [entry.id, entry]));
 		return manifest;
@@ -48,7 +416,9 @@ var SculptedRuntime = class {
 	async loadEditorMetadata() {
 		const response = await this.#environment.fetch(this.editorMetadataEndpoint, { cache: "no-store" });
 		if (!response.ok) throw new Error(`Failed to load Panda editor metadata: ${response.status}`);
-		const metadata = await response.json();
+		const parsed = await responseJson(response);
+		if (!isInspectorEditorMetadata(parsed)) throw new Error(editorMetadataLoadMessage(response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol"));
+		const metadata = parsed;
 		this.#editorMetadata = metadata;
 		return metadata;
 	}
@@ -59,7 +429,7 @@ var SculptedRuntime = class {
 		return this.#entries.get(id);
 	}
 	async requestStyleEdit(request, write) {
-		const result = await (await this.#environment.fetch(this.writebackEndpoint, {
+		const result = await styleEditResponseFromFetch(await this.#environment.fetch(this.writebackEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
@@ -70,7 +440,7 @@ var SculptedRuntime = class {
 					write
 				}
 			})
-		})).json();
+		}), request.editId);
 		if (result.ok && result.manifestUpdate) await this.loadManifest();
 		return result;
 	}
@@ -80,17 +450,17 @@ var SculptedRuntime = class {
 			requests,
 			options: { write }
 		};
-		const result = await (await this.#environment.fetch(this.writebackEndpoint, {
+		const result = await styleEditBatchResponseFromFetch(await this.#environment.fetch(this.writebackEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
 			body: JSON.stringify(batch)
-		})).json();
+		}), requests);
 		if (result.ok && result.manifestUpdate) await this.loadManifest();
 		return result.responses;
 	}
 	async requestInlineCssSource(request, write) {
-		const result = await (await this.#environment.fetch(this.writebackEndpoint, {
+		const result = await styleEditResponseFromFetch(await this.#environment.fetch(this.writebackEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
@@ -101,20 +471,20 @@ var SculptedRuntime = class {
 					write
 				}
 			})
-		})).json();
+		}), request.editId);
 		if (result.ok && result.manifestUpdate) await this.loadManifest();
 		return result;
 	}
 	async getComponentStyleModule(componentSource) {
-		return await (await this.#environment.fetch(this.styleModuleEndpoint, {
+		return componentStyleModuleResponseFromFetch(await this.#environment.fetch(this.styleModuleEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
 			body: JSON.stringify({ componentSource })
-		})).json();
+		}));
 	}
 	async requestStyleModuleEdit(request, write) {
-		const result = await (await this.#environment.fetch(this.writebackEndpoint, {
+		const result = await styleEditResponseFromFetch(await this.#environment.fetch(this.writebackEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
@@ -125,12 +495,12 @@ var SculptedRuntime = class {
 					write
 				}
 			})
-		})).json();
+		}), request.editId);
 		if (result.ok && result.manifestUpdate) await this.loadManifest();
 		return result;
 	}
 	async requestTokenConfigEdit(request, write) {
-		const result = await (await this.#environment.fetch(this.tokenWritebackEndpoint, {
+		const result = await tokenConfigEditResponseFromFetch(await this.#environment.fetch(this.tokenWritebackEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
@@ -141,17 +511,17 @@ var SculptedRuntime = class {
 					write
 				}
 			})
-		})).json();
+		}), request.editId);
 		if (result.ok && result.metadataUpdate) await this.loadEditorMetadata();
 		return result;
 	}
 	async openSourceLocation(request) {
-		const result = await (await this.#environment.fetch(this.openSourceEndpoint, {
+		const result = await openSourceLocationResponseFromFetch(await this.#environment.fetch(this.openSourceEndpoint, {
 			method: "POST",
 			cache: "no-store",
 			headers: { "content-type": "application/json" },
 			body: JSON.stringify(request)
-		})).json();
+		}));
 		if (!result.ok) return result;
 		try {
 			const editorResponse = await this.#environment.fetch(result.openEditorUrl, { cache: "no-store" });
@@ -165,6 +535,7 @@ var SculptedRuntime = class {
 				}
 			};
 		} catch (error) {
+			logUnexpectedRuntimeError("Failed to contact Vite editor opener.", error);
 			return {
 				ok: false,
 				error: {
@@ -384,7 +755,8 @@ var SculptedRuntime = class {
 			attributes: attributeSnapshot(element),
 			bounds: boundsSnapshot(element),
 			ancestors: ancestorSnapshot(element),
-			componentLayers: componentLayerSnapshot(element, this.#attributes)
+			componentLayers: componentLayerSnapshot(element, this.#attributes),
+			inheritedStyleSources: inheritedStyleSourceSnapshot(this.#environment.window, element, this.#attributes, this.#entries)
 		};
 	}
 	#previewStyleElement() {
@@ -445,6 +817,9 @@ function installSculptedRuntime(options = {}) {
 	environment.window[globalName] = runtime;
 	return runtime;
 }
+function logUnexpectedRuntimeError(message, error) {
+	console.error(`[sculpted] ${message}`, error);
+}
 function browserEnvironment() {
 	if (typeof window === "undefined" || typeof document === "undefined") throw new Error("Sculpted runtime requires a browser environment.");
 	return {
@@ -512,6 +887,46 @@ function ancestorSnapshot(element) {
 	}
 	return ancestors;
 }
+function inheritedStyleSourceSnapshot(window, element, attributes, entries) {
+	const sources = [];
+	let current = element.parentElement;
+	let depth = 1;
+	while (current && depth < 24) {
+		if (isInspectorOwnedElement(current)) break;
+		const targetIds = targetIdsForElement(current, attributes, entries);
+		for (const targetId of targetIds) {
+			const target = entries.get(targetId);
+			if (!target || !isEditableTarget(target)) continue;
+			sources.push({
+				target,
+				depth,
+				tagName: current.tagName.toLowerCase(),
+				source: current.getAttribute(attributes.source) ?? void 0,
+				component: current.getAttribute(attributes.component) ?? void 0,
+				computedStyles: inheritedComputedStyleSnapshot(window, current)
+			});
+		}
+		current = current.parentElement;
+		depth += 1;
+	}
+	return sources;
+}
+function targetIdsForElement(element, attributes, entries) {
+	const markerEditIds = editIdsFromMarkerClassList(element.getAttribute("class") ?? "");
+	if (markerEditIds.length > 0) return markerEditIds;
+	const attributeEditIds = (element.getAttribute(attributes.editId) ?? "").split(/\s+/).filter(Boolean);
+	if (attributeEditIds.length > 0) return attributeEditIds;
+	const jsxSource = element.getAttribute(attributes.jsxSource)?.trim();
+	if (!jsxSource) return [];
+	return Array.from(entries.values()).filter((entry) => entry.jsxSource === jsxSource || (entry.jsxSourceAliases ?? []).includes(jsxSource)).map((entry) => entry.id);
+}
+function inheritedComputedStyleSnapshot(window, element) {
+	const style = window.getComputedStyle(element);
+	return INHERITED_CSS_PROPERTIES.map((property) => ({
+		property,
+		value: style.getPropertyValue(property)
+	})).filter((declaration) => declaration.value.trim().length > 0);
+}
 function componentLayerSnapshot(element, attributes) {
 	const layers = [];
 	const pendingElements = [];
@@ -596,6 +1011,99 @@ function isShadowRoot(root) {
 function isEditableTarget(target) {
 	return target.kind === "panda-css";
 }
+function manifestLoadMessage(response, reason) {
+	const status = response.status ? ` HTTP ${response.status}` : "";
+	return reason === "invalid-json" ? `Sculpted manifest endpoint returned invalid JSON${status}.` : `Sculpted manifest endpoint returned an invalid response${status}.`;
+}
+function editorMetadataLoadMessage(response, reason) {
+	const status = response.status ? ` HTTP ${response.status}` : "";
+	return reason === "invalid-json" ? `Panda editor metadata endpoint returned invalid JSON${status}.` : `Panda editor metadata endpoint returned an invalid response${status}.`;
+}
+async function styleEditResponseFromFetch(response, editId) {
+	const parsed = await responseJson(response);
+	if (isStyleEditResponseForEditId(parsed, editId)) return parsed;
+	return styleEditFailure(editId, writebackResponseMessage(response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol"));
+}
+async function styleEditBatchResponseFromFetch(response, requests) {
+	const parsed = await responseJson(response);
+	if (isStyleEditBatchResponse(parsed)) {
+		if (!parsed.ok) return parsed;
+		if (parsed.responses.length === requests.length && parsed.responses.every((item, index) => item.ok && item.editId === requests[index]?.editId)) return parsed;
+	}
+	const failure = styleEditFailure(requests.map((request) => request.editId).join(" "), writebackResponseMessage(response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol"));
+	return {
+		ok: false,
+		editId: "",
+		written: false,
+		responses: requests.length > 0 ? requests.map((request) => ({
+			...failure,
+			editId: request.editId
+		})) : [failure],
+		error: failure.error
+	};
+}
+async function tokenConfigEditResponseFromFetch(response, editId) {
+	const parsed = await responseJson(response);
+	if (isTokenConfigEditResponse(parsed, editId)) return parsed;
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code: "write-failed",
+			message: writebackResponseMessage(response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol")
+		}
+	};
+}
+async function componentStyleModuleResponseFromFetch(response) {
+	const parsed = await responseJson(response);
+	if (isComponentStyleModuleResponse(parsed)) return parsed;
+	return {
+		ok: false,
+		error: {
+			code: "write-failed",
+			message: devServerResponseMessage("Style-module endpoint", response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol")
+		}
+	};
+}
+async function openSourceLocationResponseFromFetch(response) {
+	const parsed = await responseJson(response);
+	if (isOpenSourceLocationResponse(parsed)) return parsed;
+	return {
+		ok: false,
+		error: {
+			code: "open-failed",
+			message: devServerResponseMessage("Open-source endpoint", response, parsed === invalidResponseJson ? "invalid-json" : "invalid-protocol")
+		}
+	};
+}
+const invalidResponseJson = Symbol("invalid-response-json");
+async function responseJson(response) {
+	try {
+		return await response.json();
+	} catch {
+		return invalidResponseJson;
+	}
+}
+function styleEditFailure(editId, message) {
+	return {
+		ok: false,
+		editId,
+		written: false,
+		error: {
+			code: "write-failed",
+			message
+		}
+	};
+}
+function writebackResponseMessage(response, reason) {
+	const status = response.status ? ` HTTP ${response.status}` : "";
+	return reason === "invalid-json" ? `Writeback endpoint returned invalid JSON${status}.` : `Writeback endpoint returned an invalid response${status}.`;
+}
+function devServerResponseMessage(endpoint, response, reason) {
+	const status = response.status ? ` HTTP ${response.status}` : "";
+	return reason === "invalid-json" ? `${endpoint} returned invalid JSON${status}.` : `${endpoint} returned an invalid response${status}.`;
+}
 function escapeCssAttribute(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
 }

package/dist/{sourceSyntax-U2iybN9L.d.mts → sourceSyntax-DKIh-VKA.d.mts}

@@ -1,4 +1,4 @@
-import { V as SourceRange, z as SourceLocation } from "./types-CdByW0ji.mjs";
+import { B as SourceLocation, H as SourceRange } from "./types-0a4hNfAF.mjs";
 import ts from "typescript";
 
 //#region src/sourceSyntax.d.ts

package/dist/tsrx.d.mts

@@ -1,4 +1,4 @@
-import { s as SourceParserAdapter } from "./sourceSyntax-U2iybN9L.mjs";
+import { s as SourceParserAdapter } from "./sourceSyntax-DKIh-VKA.mjs";
 
 //#region src/tsrx.d.ts
 declare const sourceSyntax: SourceParserAdapter;