@ai-gui/plugin-map 0.4.0

package/dist/index.cjs

@@ -0,0 +1,877 @@
+"use strict";
+
+//#region src/css.ts
+const mapCss = `
+[data-aigui-map]{display:block;max-width:100%}
+[data-aigui-map-canvas]{position:relative;width:100%;height:var(--aigui-map-height,360px);min-height:240px;overflow:hidden;background:#e8edf1;outline:none}
+[data-aigui-map-canvas]:focus-visible{outline:3px solid #2563eb;outline-offset:2px}
+[data-aigui-map-controls]{position:absolute;z-index:800;top:10px;right:10px;display:flex;gap:8px;flex-wrap:wrap}
+[data-aigui-map-controls] button{min-width:44px;min-height:44px;border:1px solid #64748b;border-radius:6px;background:#fff;color:#111827;font:inherit;padding:8px 12px;cursor:pointer}
+[data-aigui-map-summary]{margin-top:12px}
+.leaflet-pane,.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-tile-container,.leaflet-pane>svg,.leaflet-pane>canvas,.leaflet-zoom-box,.leaflet-image-layer,.leaflet-layer{position:absolute;left:0;top:0}
+.leaflet-container{overflow:hidden;-webkit-tap-highlight-color:transparent}.leaflet-container img,.leaflet-container svg{max-width:none!important;max-height:none!important}.leaflet-tile{visibility:hidden}.leaflet-tile-loaded{visibility:inherit}.leaflet-zoom-animated{transform-origin:0 0}.leaflet-zoom-hide{visibility:hidden}.leaflet-control-container{position:relative;z-index:800}.leaflet-control{position:relative;z-index:800;pointer-events:auto}.leaflet-top,.leaflet-bottom{position:absolute;z-index:1000;pointer-events:none}.leaflet-top{top:0}.leaflet-right{right:0}.leaflet-bottom{bottom:0}.leaflet-left{left:0}.leaflet-control-zoom a{display:block;width:44px;height:44px;line-height:44px;text-align:center;background:#fff;color:#111;text-decoration:none}.leaflet-tooltip{position:absolute;padding:6px;background:#fff;border:1px solid #64748b;border-radius:4px;color:#111;white-space:nowrap;pointer-events:none}
+@media (prefers-reduced-motion:reduce){[data-aigui-map] *{scroll-behavior:auto!important;transition:none!important;animation:none!important}}
+`;
+
+//#endregion
+//#region src/mount.ts
+const WORLD = [[-85.05112878, -180], [85.05112878, 180]];
+const PAINT = {
+	default: {
+		color: "#334155",
+		fillColor: "#64748b",
+		fillOpacity: .25,
+		weight: 3
+	},
+	accent: {
+		color: "#1d4ed8",
+		fillColor: "#3b82f6",
+		fillOpacity: .28,
+		weight: 3
+	},
+	muted: {
+		color: "#64748b",
+		fillColor: "#94a3b8",
+		fillOpacity: .2,
+		weight: 2
+	},
+	positive: {
+		color: "#15803d",
+		fillColor: "#22c55e",
+		fillOpacity: .25,
+		weight: 3
+	},
+	warning: {
+		color: "#b45309",
+		fillColor: "#f59e0b",
+		fillOpacity: .28,
+		weight: 3
+	},
+	critical: {
+		color: "#b91c1c",
+		fillColor: "#ef4444",
+		fillOpacity: .28,
+		weight: 3
+	}
+};
+function mountMapDocument(host, document, options) {
+	if (!host || typeof host.replaceChildren !== "function") throw new TypeError("mountMapDocument requires an HTMLElement host.");
+	const canvas = globalThis.document.createElement("div");
+	canvas.setAttribute("data-aigui-map-canvas", "");
+	canvas.setAttribute("role", "region");
+	canvas.setAttribute("aria-label", document.ariaLabel ?? "Interactive map");
+	canvas.tabIndex = 0;
+	canvas.style.setProperty("--aigui-map-height", `${options.height}px`);
+	const controls = globalThis.document.createElement("div");
+	controls.setAttribute("data-aigui-map-controls", "");
+	const status = globalThis.document.createElement("div");
+	status.setAttribute("role", "status");
+	status.setAttribute("aria-live", "polite");
+	status.hidden = true;
+	canvas.append(controls, status);
+	host.replaceChildren(canvas);
+	let disposed = false;
+	let map$1;
+	let resize;
+	const listeners = [];
+	import("leaflet").then((module$1) => {
+		if (disposed) return;
+		const L = "default" in module$1 ? module$1.default : module$1;
+		map$1 = L.map(canvas, {
+			zoomControl: false,
+			attributionControl: false,
+			minZoom: options.minZoom,
+			maxZoom: options.maxZoom,
+			maxBounds: WORLD,
+			dragging: options.dragging,
+			touchZoom: options.touchZoom,
+			doubleClickZoom: options.doubleClickZoom,
+			scrollWheelZoom: options.scrollWheelZoom,
+			keyboard: options.keyboard
+		});
+		map$1.setMaxBounds(WORLD);
+		if (options.basemap) {
+			L.tileLayer(options.basemap.tileUrlTemplate, {
+				attribution: "",
+				minZoom: options.basemap.minZoom,
+				maxZoom: options.basemap.maxZoom,
+				maxNativeZoom: options.basemap.maxNativeZoom,
+				tileSize: options.basemap.tileSize
+			}).addTo(map$1);
+			canvas.appendChild(attribution(options.basemap.attribution));
+		}
+		const layers = [];
+		for (const layer of document.layers) addLayer(L, map$1, layer, layers);
+		const bounds = layers.length ? L.featureGroup(layers).getBounds() : void 0;
+		const reduced = globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+		const reset = () => {
+			if (!map$1) return;
+			if (document.view) map$1.setView(toLatLng(document.view.center), clamp(document.view.zoom, options.minZoom, options.maxZoom), { animate: !reduced });
+			else fit(map$1, bounds, options.maxFitZoom, reduced);
+			announce(status, "Map view reset.");
+		};
+		const fitData = () => {
+			if (map$1) {
+				fit(map$1, bounds, options.maxFitZoom, reduced);
+				announce(status, "Map fitted to data.");
+			}
+		};
+		if (document.view) reset();
+		else fitData();
+		if (options.controls.zoom) L.control.zoom({ position: "topleft" }).addTo(map$1);
+		if (options.controls.reset) listeners.push(button(controls, "Reset map view", reset));
+		if (options.controls.fit) listeners.push(button(controls, "Fit map data", fitData));
+		if (typeof ResizeObserver !== "undefined") {
+			resize = new ResizeObserver(() => map$1?.invalidateSize({ pan: false }));
+			resize.observe(canvas);
+		}
+	}).catch(() => {
+		if (!disposed) announce(status, "Map unavailable.");
+	});
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		listeners.splice(0).forEach((remove) => remove());
+		resize?.disconnect();
+		map$1?.remove();
+		map$1 = void 0;
+		host.replaceChildren();
+	};
+}
+function addLayer(L, map$1, layer, layers) {
+	if (layer.type === "markers") for (const item of layer.items) {
+		const marker = L.circleMarker(toLatLng(item.position), {
+			...paint(item.variant),
+			radius: 7
+		}).addTo(map$1);
+		marker.bindTooltip(tooltip([item.label, item.description]));
+		layers.push(marker);
+	}
+	else if (layer.type === "route") {
+		const route = L.polyline(layer.coordinates.map(toLatLng), paint(layer.variant)).addTo(map$1);
+		if (layer.label || layer.description) route.bindTooltip(tooltip([layer.label, layer.description]));
+		layers.push(route);
+	} else {
+		const geo = L.geoJSON(swapFeatureCollection(layer), {
+			style: paint(layer.variant),
+			pointToLayer: (_feature, latlng) => L.circleMarker(latlng, {
+				...paint(layer.variant),
+				radius: 7
+			}),
+			onEachFeature: (feature, featureLayer) => {
+				const lines = geoTooltip(layer, feature);
+				if (lines.length) featureLayer.bindTooltip(tooltip(lines));
+			}
+		}).addTo(map$1);
+		layers.push(geo);
+	}
+}
+function geoTooltip(layer, feature) {
+	const result = [];
+	const label = featureLabel(layer, feature);
+	if (label) result.push(label);
+	for (const key of layer.tooltipProperties ?? []) {
+		const value = feature.properties?.[key];
+		if (value !== void 0 && value !== null) result.push(`${key}: ${String(value)}`);
+	}
+	return result;
+}
+function featureLabel(layer, feature) {
+	const value = layer.labelProperty ? feature.properties?.[layer.labelProperty] : void 0;
+	return value === void 0 || value === null ? void 0 : String(value);
+}
+function tooltip(lines) {
+	const node = globalThis.document.createElement("span");
+	node.textContent = lines.filter(Boolean).join("\n");
+	return node;
+}
+function paint(variant$1) {
+	return PAINT[variant$1 ?? "default"];
+}
+function toLatLng(position$1) {
+	return [position$1[1], position$1[0]];
+}
+function fit(map$1, bounds, maxZoom, reduced) {
+	if (bounds?.isValid()) map$1.fitBounds(bounds, {
+		padding: [24, 24],
+		maxZoom,
+		animate: !reduced
+	});
+	else map$1.setView([0, 0], 2, { animate: !reduced });
+}
+function button(host, label, action) {
+	const element = globalThis.document.createElement("button");
+	element.type = "button";
+	element.textContent = label;
+	element.setAttribute("aria-label", label);
+	element.addEventListener("click", action);
+	host.appendChild(element);
+	return () => element.removeEventListener("click", action);
+}
+function announce(status, text$1) {
+	status.hidden = false;
+	status.textContent = text$1;
+}
+function attribution(value) {
+	const node = globalThis.document.createElement("div");
+	node.setAttribute("data-aigui-map-attribution", "");
+	if (value.url) {
+		const link = globalThis.document.createElement("a");
+		link.href = value.url;
+		link.target = "_blank";
+		link.rel = "noopener noreferrer";
+		link.textContent = value.text;
+		node.appendChild(link);
+	} else node.textContent = value.text;
+	return node;
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function swapFeatureCollection(layer) {
+	return {
+		type: "FeatureCollection",
+		features: layer.data.features.map((feature) => ({
+			...feature,
+			geometry: swapGeometry(feature.geometry)
+		}))
+	};
+}
+function swapGeometry(geometry) {
+	const swap = (value) => Array.isArray(value) && value.length === 2 && typeof value[0] === "number" ? [value[0], value[1]] : Array.isArray(value) ? value.map(swap) : value;
+	return {
+		type: geometry.type,
+		coordinates: swap(geometry.coordinates)
+	};
+}
+
+//#endregion
+//#region src/options.ts
+const OPTION_KEYS = set$1("height", "minZoom", "maxZoom", "maxFitZoom", "dragging", "touchZoom", "doubleClickZoom", "scrollWheelZoom", "keyboard", "controls", "basemap", "networkPolicy");
+const CONTROL_KEYS = set$1("zoom", "reset", "fit");
+const BASEMAP_KEYS = set$1("tileUrlTemplate", "attribution", "minZoom", "maxZoom", "maxNativeZoom", "tileSize");
+const ATTRIBUTION_KEYS = set$1("text", "url");
+const POLICY_KEYS = set$1("allowedTileOrigins");
+function resolveMapOptions(options = {}) {
+	assertSafeOptions(options);
+	plain(options, "map options");
+	exact(options, OPTION_KEYS, "map options");
+	const height = integer(options.height, 240, 720, 360, "height");
+	const minZoom = integer(options.minZoom, 0, 22, 0, "minZoom");
+	const maxZoom = integer(options.maxZoom, 0, 22, 22, "maxZoom");
+	if (minZoom > maxZoom) fail("minZoom cannot exceed maxZoom.");
+	const maxFitZoom = integer(options.maxFitZoom, minZoom, maxZoom, maxZoom, "maxFitZoom");
+	const controls = options.controls ?? {};
+	plain(controls, "controls");
+	exact(controls, CONTROL_KEYS, "controls");
+	const basemap = options.basemap ?? false;
+	let validatedBasemap = false;
+	if (basemap !== false) {
+		plain(basemap, "basemap");
+		exact(basemap, BASEMAP_KEYS, "basemap");
+		plain(basemap.attribution, "basemap.attribution");
+		exact(basemap.attribution, ATTRIBUTION_KEYS, "basemap.attribution");
+		boundedText(basemap.attribution.text, "basemap.attribution.text");
+		if (basemap.attribution.url !== void 0) safeUrl(basemap.attribution.url, "basemap.attribution.url", false);
+		const tileURL = safeUrl(basemap.tileUrlTemplate, "basemap.tileUrlTemplate", true);
+		const tileMin = integer(basemap.minZoom, 0, 22, minZoom, "basemap.minZoom");
+		const tileMax = integer(basemap.maxZoom, 0, 22, maxZoom, "basemap.maxZoom");
+		if (tileMin > tileMax || tileMin < minZoom || tileMax > maxZoom) fail("Basemap zoom range must fit map zoom range.");
+		const maxNativeZoom = integer(basemap.maxNativeZoom, tileMin, tileMax, tileMax, "basemap.maxNativeZoom");
+		const tileSize = integer(basemap.tileSize, 128, 512, 256, "basemap.tileSize");
+		if (!options.networkPolicy) fail("networkPolicy.allowedTileOrigins is required for a basemap.");
+		plain(options.networkPolicy, "networkPolicy");
+		exact(options.networkPolicy, POLICY_KEYS, "networkPolicy");
+		if (!Array.isArray(options.networkPolicy.allowedTileOrigins) || options.networkPolicy.allowedTileOrigins.length === 0) fail("allowedTileOrigins must be a non-empty array.");
+		const origins = options.networkPolicy.allowedTileOrigins.map((origin) => normalizedOrigin(origin));
+		if (!origins.includes(tileURL.origin)) fail("Tile URL origin is not allowed by networkPolicy.");
+		validatedBasemap = {
+			tileUrlTemplate: basemap.tileUrlTemplate,
+			attribution: basemap.attribution,
+			minZoom: tileMin,
+			maxZoom: tileMax,
+			maxNativeZoom,
+			tileSize
+		};
+	} else if (options.networkPolicy !== void 0) {
+		plain(options.networkPolicy, "networkPolicy");
+		exact(options.networkPolicy, POLICY_KEYS, "networkPolicy");
+		if (!Array.isArray(options.networkPolicy.allowedTileOrigins)) fail("allowedTileOrigins must be an array.");
+		options.networkPolicy.allowedTileOrigins.forEach(normalizedOrigin);
+	}
+	return {
+		height,
+		minZoom,
+		maxZoom,
+		maxFitZoom,
+		dragging: bool(options.dragging, true, "dragging"),
+		touchZoom: bool(options.touchZoom, true, "touchZoom"),
+		doubleClickZoom: bool(options.doubleClickZoom, true, "doubleClickZoom"),
+		scrollWheelZoom: bool(options.scrollWheelZoom, false, "scrollWheelZoom"),
+		keyboard: bool(options.keyboard, true, "keyboard"),
+		controls: {
+			zoom: bool(controls.zoom, true, "controls.zoom"),
+			reset: bool(controls.reset, true, "controls.reset"),
+			fit: bool(controls.fit, true, "controls.fit")
+		},
+		basemap: validatedBasemap,
+		networkPolicy: options.networkPolicy
+	};
+}
+function safeUrl(value, name, template) {
+	if (typeof value !== "string" || value.length > 2048) fail(`${name} must be a bounded URL string.`);
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		fail(`${name} must be an absolute URL.`);
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.hash) fail(`${name} must be a safe HTTP(S) URL.`);
+	const placeholders = [...value.matchAll(/\{([^}]+)\}/g)];
+	if (value.replace(/\{[^}]+\}/g, "").includes("{") || value.replace(/\{[^}]+\}/g, "").includes("}")) fail(`${name} contains malformed placeholders.`);
+	const authorityEnd = value.indexOf("/", value.indexOf("//") + 2);
+	for (const match of placeholders) if (![
+		"z",
+		"x",
+		"y",
+		"r"
+	].includes(match[1]) || (match.index ?? 0) < authorityEnd) fail(`${name} contains an unsupported placeholder.`);
+	if (template && ![
+		"z",
+		"x",
+		"y"
+	].every((key) => placeholders.some((match) => match[1] === key))) fail(`${name} must contain z, x, and y placeholders.`);
+	if (!template && placeholders.length) fail(`${name} cannot contain placeholders.`);
+	return parsed;
+}
+function normalizedOrigin(value) {
+	if (typeof value !== "string") fail("Allowed tile origins must be strings.");
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		fail("Allowed tile origins must be absolute origins.");
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash || url.pathname !== "/" || url.search || value !== url.origin) fail("Allowed tile origins must be exact normalized HTTP(S) origins.");
+	return url.origin;
+}
+function integer(value, min, max, fallback, name) {
+	if (value === void 0) return fallback;
+	if (!Number.isInteger(value) || value < min || value > max) fail(`${name} must be an integer from ${min} to ${max}.`);
+	return value;
+}
+function bool(value, fallback, name) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") fail(`${name} must be boolean.`);
+	return value;
+}
+function boundedText(value, name) {
+	if (typeof value !== "string" || value.trim() === "" || value.length > 512) fail(`${name} must be a non-empty bounded string.`);
+}
+function plain(value, name) {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) fail(`${name} must be a plain object.`);
+}
+function exact(value, allowed, name) {
+	for (const key of Object.keys(value)) if (!allowed.has(key) || [
+		"__proto__",
+		"prototype",
+		"constructor"
+	].includes(key)) fail(`${name}.${key} is not allowed.`);
+}
+function set$1(...keys) {
+	return new Set(keys);
+}
+function fail(message) {
+	throw new TypeError(message);
+}
+function assertSafeOptions(value) {
+	const active = new Set(), visited = new Set();
+	const walk = (current) => {
+		if (typeof current === "number" && !Number.isFinite(current)) fail("Map options must contain finite numbers.");
+		if (typeof current !== "object" || current === null) return;
+		if (active.has(current)) fail("Map options must not contain cycles.");
+		if (visited.has(current)) return;
+		if (!Array.isArray(current) && Object.getPrototypeOf(current) !== Object.prototype) fail("Map options must use plain objects.");
+		if (Array.isArray(current)) {
+			for (let index = 0; index < current.length; index++) if (!Object.hasOwn(current, index)) fail("Map option arrays must not be sparse.");
+		}
+		active.add(current);
+		visited.add(current);
+		for (const key of Object.keys(current)) {
+			if ([
+				"__proto__",
+				"prototype",
+				"constructor"
+			].includes(key)) fail(`Dangerous option key "${key}" is not allowed.`);
+			const descriptor = Object.getOwnPropertyDescriptor(current, key);
+			if (!descriptor || descriptor.get || descriptor.set) fail("Map options must not contain accessors.");
+			walk(descriptor.value);
+		}
+		active.delete(current);
+	};
+	walk(value);
+}
+
+//#endregion
+//#region src/prompt.ts
+function mapPromptSpec() {
+	return [
+		"Maps (one complete fenced block maximum): ```map <strict MapDocument JSON>```.",
+		"MapDocument is exact: {\"version\":1,\"ariaLabel\"?:string,\"view\"?:{\"center\":[lon,lat],\"zoom\":0..22},\"layers\":[...]}.",
+		"Use maps, rather than ECharts, for inline GeoJSON, markers, routes, and user map navigation.",
+		"Layers are exact geojson FeatureCollections, marker items, or route coordinates; variants are default, accent, muted, positive, warning, or critical.",
+		"The model controls data only. The host controls navigation controls, basemap, and network policy.",
+		"Never include tile URLs, tokens, remote GeoJSON, geocoding, HTML, scripts, CSS, style expressions, images, callbacks, options, colors, or network fields."
+	].join("\n");
+}
+
+//#endregion
+//#region src/errors.ts
+var MapDocumentError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues[0] ?? "Invalid map document.");
+		this.name = "MapDocumentError";
+		this.issues = [...issues];
+	}
+};
+var MapLimitError = class extends MapDocumentError {
+	constructor(message) {
+		super([message]);
+		this.name = "MapLimitError";
+	}
+};
+
+//#endregion
+//#region src/limits.ts
+const DEFAULT_MAP_LIMITS = Object.freeze({
+	sourceBytes: 256 * 1024,
+	layers: 16,
+	features: 500,
+	markers: 500,
+	coordinatePositions: 2e4,
+	routePositions: 5e3,
+	geometryDepth: 8,
+	properties: 16,
+	tooltipProperties: 8,
+	string: 512,
+	totalStrings: 64 * 1024,
+	id: 128
+});
+
+//#endregion
+//#region src/validate.ts
+const SAFE_ID = /^[A-Za-z][A-Za-z0-9_-]{0,127}$/;
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+const VARIANTS = new Set([
+	"default",
+	"accent",
+	"muted",
+	"positive",
+	"warning",
+	"critical"
+]);
+const DOCUMENT_KEYS = set("version", "ariaLabel", "view", "layers");
+const VIEW_KEYS = set("center", "zoom");
+const LAYER_KEYS = {
+	geojson: set("id", "type", "data", "labelProperty", "tooltipProperties", "variant"),
+	markers: set("id", "type", "items"),
+	route: set("id", "type", "coordinates", "label", "description", "variant")
+};
+const FEATURE_COLLECTION_KEYS = set("type", "features");
+const FEATURE_KEYS = set("type", "id", "properties", "geometry");
+const GEOMETRY_KEYS = set("type", "coordinates");
+const MARKER_KEYS = set("id", "position", "label", "description", "variant");
+function parseMapDocument(source) {
+	if (typeof source !== "string") throw new MapDocumentError(["Map source must be a string."]);
+	if (new TextEncoder().encode(source).byteLength > DEFAULT_MAP_LIMITS.sourceBytes) throw new MapLimitError("Map source exceeds 256 KiB.");
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		throw new MapDocumentError(["Map source must be valid JSON."]);
+	}
+	return validateMapDocument(value);
+}
+function validateMapDocument(value) {
+	assertSafeGraph(value);
+	const issues = [];
+	if (!isPlainObject(value)) throw new MapDocumentError(["Map document must be a plain object."]);
+	rejectKeys(value, DOCUMENT_KEYS, "$", issues);
+	if (value.version !== 1) issues.push("$.version must be 1.");
+	const ctx = {
+		limits: DEFAULT_MAP_LIMITS,
+		issues,
+		ids: new Set(),
+		features: 0,
+		markers: 0,
+		positions: 0,
+		strings: 0
+	};
+	optionalString(value.ariaLabel, "$.ariaLabel", ctx);
+	validateView(value.view, ctx);
+	if (!Array.isArray(value.layers)) issues.push("$.layers must be an array.");
+	else {
+		if (value.layers.length > ctx.limits.layers) throw new MapLimitError(`Map exceeds ${ctx.limits.layers} layers.`);
+		value.layers.forEach((layer, index) => validateLayer(layer, `$.layers[${index}]`, ctx));
+	}
+	if (issues.length) throw new MapDocumentError(issues);
+	return value;
+}
+function validateView(value, ctx) {
+	if (value === void 0) return;
+	if (!isPlainObject(value)) {
+		ctx.issues.push("$.view must be a plain object.");
+		return;
+	}
+	rejectKeys(value, VIEW_KEYS, "$.view", ctx.issues);
+	position(value.center, "$.view.center", ctx);
+	if (!Number.isInteger(value.zoom) || value.zoom < 0 || value.zoom > 22) ctx.issues.push("$.view.zoom must be an integer from 0 to 22.");
+}
+function validateLayer(value, path, ctx) {
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return;
+	}
+	const type = typeof value.type === "string" ? value.type : "";
+	const keys = LAYER_KEYS[type];
+	if (!keys) {
+		ctx.issues.push(`${path}.type is unsupported.`);
+		return;
+	}
+	rejectKeys(value, keys, path, ctx.issues);
+	id(value.id, `${path}.id`, ctx);
+	if (type === "geojson") validateGeoJSONLayer(value, path, ctx);
+	else if (type === "markers") validateMarkersLayer(value, path, ctx);
+	else validateRouteLayer(value, path, ctx);
+}
+function validateGeoJSONLayer(value, path, ctx) {
+	variant(value.variant, `${path}.variant`, ctx);
+	const labelProperty = optionalString(value.labelProperty, `${path}.labelProperty`, ctx);
+	if (labelProperty !== void 0 && DANGEROUS_KEYS.has(labelProperty)) ctx.issues.push(`${path}.labelProperty is dangerous.`);
+	if (value.tooltipProperties !== void 0) if (!Array.isArray(value.tooltipProperties) || value.tooltipProperties.length > ctx.limits.tooltipProperties) ctx.issues.push(`${path}.tooltipProperties must contain at most ${ctx.limits.tooltipProperties} strings.`);
+	else {
+		const seen = new Set();
+		value.tooltipProperties.forEach((item, index) => {
+			const key = requiredString(item, `${path}.tooltipProperties[${index}]`, ctx);
+			if (key && (DANGEROUS_KEYS.has(key) || seen.has(key))) ctx.issues.push(`${path}.tooltipProperties[${index}] must be safe and unique.`);
+			if (key) seen.add(key);
+		});
+	}
+	const data = value.data;
+	if (!isPlainObject(data)) {
+		ctx.issues.push(`${path}.data must be a FeatureCollection.`);
+		return;
+	}
+	rejectKeys(data, FEATURE_COLLECTION_KEYS, `${path}.data`, ctx.issues);
+	if (data.type !== "FeatureCollection" || !Array.isArray(data.features)) {
+		ctx.issues.push(`${path}.data must be an exact FeatureCollection.`);
+		return;
+	}
+	if (ctx.features + data.features.length > ctx.limits.features) throw new MapLimitError(`Map exceeds ${ctx.limits.features} features.`);
+	ctx.features += data.features.length;
+	data.features.forEach((feature, index) => validateFeature(feature, `${path}.data.features[${index}]`, ctx));
+}
+function validateFeature(value, path, ctx) {
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return;
+	}
+	rejectKeys(value, FEATURE_KEYS, path, ctx.issues);
+	if (value.type !== "Feature") ctx.issues.push(`${path}.type must be Feature.`);
+	if (typeof value.id === "string") id(value.id, `${path}.id`, ctx);
+	else if (typeof value.id === "number" && Number.isFinite(value.id)) {
+		const key = `#${value.id}`;
+		if (ctx.ids.has(key)) ctx.issues.push(`${path}.id must be unique.`);
+		ctx.ids.add(key);
+	} else if (value.id !== void 0) ctx.issues.push(`${path}.id must be a safe string or finite number.`);
+	if (value.properties !== void 0) validateProperties(value.properties, `${path}.properties`, ctx);
+	validateGeometry(value.geometry, `${path}.geometry`, 1, ctx);
+}
+function validateProperties(value, path, ctx) {
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return;
+	}
+	const entries = Object.entries(value);
+	if (entries.length > ctx.limits.properties) ctx.issues.push(`${path} exceeds ${ctx.limits.properties} properties.`);
+	for (const [key, item] of entries) {
+		if (DANGEROUS_KEYS.has(key) || key.length > ctx.limits.string) ctx.issues.push(`${path}.${key} is not a safe property.`);
+		countString(key, path, ctx);
+		if (!isScalar(item)) ctx.issues.push(`${path}.${key} must be a scalar.`);
+		else if (typeof item === "string") countString(item, `${path}.${key}`, ctx);
+	}
+}
+function validateGeometry(value, path, depth, ctx) {
+	if (depth > ctx.limits.geometryDepth) {
+		ctx.issues.push(`${path} exceeds geometry depth.`);
+		return;
+	}
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a supported geometry.`);
+		return;
+	}
+	rejectKeys(value, GEOMETRY_KEYS, path, ctx.issues);
+	const geometry = value;
+	switch (geometry.type) {
+		case "Point":
+			position(geometry.coordinates, `${path}.coordinates`, ctx);
+			break;
+		case "MultiPoint":
+			positions(geometry.coordinates, `${path}.coordinates`, 0, ctx);
+			break;
+		case "LineString":
+			positions(geometry.coordinates, `${path}.coordinates`, 2, ctx);
+			break;
+		case "MultiLineString":
+			nestedLines(geometry.coordinates, `${path}.coordinates`, ctx);
+			break;
+		case "Polygon":
+			polygon(geometry.coordinates, `${path}.coordinates`, ctx);
+			break;
+		case "MultiPolygon": {
+			if (!Array.isArray(geometry.coordinates)) ctx.issues.push(`${path}.coordinates must be an array.`);
+			else geometry.coordinates.forEach((item, index) => polygon(item, `${path}.coordinates[${index}]`, ctx));
+			break;
+		}
+		default: ctx.issues.push(`${path}.type is unsupported.`);
+	}
+}
+function validateMarkersLayer(value, path, ctx) {
+	if (!Array.isArray(value.items)) {
+		ctx.issues.push(`${path}.items must be an array.`);
+		return;
+	}
+	if (ctx.markers + value.items.length > ctx.limits.markers) throw new MapLimitError(`Map exceeds ${ctx.limits.markers} markers.`);
+	ctx.markers += value.items.length;
+	value.items.forEach((item, index) => {
+		const itemPath = `${path}.items[${index}]`;
+		if (!isPlainObject(item)) {
+			ctx.issues.push(`${itemPath} must be a plain object.`);
+			return;
+		}
+		rejectKeys(item, MARKER_KEYS, itemPath, ctx.issues);
+		id(item.id, `${itemPath}.id`, ctx);
+		position(item.position, `${itemPath}.position`, ctx);
+		requiredString(item.label, `${itemPath}.label`, ctx);
+		optionalString(item.description, `${itemPath}.description`, ctx);
+		variant(item.variant, `${itemPath}.variant`, ctx);
+	});
+}
+function validateRouteLayer(value, path, ctx) {
+	if (Array.isArray(value.coordinates) && value.coordinates.length > ctx.limits.routePositions) throw new MapLimitError(`Route exceeds ${ctx.limits.routePositions} positions.`);
+	positions(value.coordinates, `${path}.coordinates`, 2, ctx);
+	optionalString(value.label, `${path}.label`, ctx);
+	optionalString(value.description, `${path}.description`, ctx);
+	variant(value.variant, `${path}.variant`, ctx);
+}
+function polygon(value, path, ctx) {
+	if (!Array.isArray(value) || value.length === 0) {
+		ctx.issues.push(`${path} must contain polygon rings.`);
+		return;
+	}
+	value.forEach((ring, index) => {
+		positions(ring, `${path}[${index}]`, 4, ctx);
+		if (Array.isArray(ring) && ring.length >= 2 && !samePosition(ring[0], ring[ring.length - 1])) ctx.issues.push(`${path}[${index}] must be closed.`);
+	});
+}
+function nestedLines(value, path, ctx) {
+	if (!Array.isArray(value)) ctx.issues.push(`${path} must be an array.`);
+	else value.forEach((line, index) => positions(line, `${path}[${index}]`, 2, ctx));
+}
+function positions(value, path, min, ctx) {
+	if (!Array.isArray(value) || value.length < min) {
+		ctx.issues.push(`${path} must contain at least ${min} positions.`);
+		return;
+	}
+	value.forEach((item, index) => position(item, `${path}[${index}]`, ctx));
+}
+function position(value, path, ctx) {
+	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "number" || typeof value[1] !== "number" || !Number.isFinite(value[0]) || !Number.isFinite(value[1])) {
+		ctx.issues.push(`${path} must be [longitude, latitude].`);
+		return false;
+	}
+	if (value[0] < -180 || value[0] > 180) ctx.issues.push(`${path}[0] must be from -180 to 180.`);
+	if (value[1] < -85.05112878 || value[1] > 85.05112878) ctx.issues.push(`${path}[1] must be within Web Mercator latitude bounds.`);
+	if (++ctx.positions > ctx.limits.coordinatePositions) throw new MapLimitError(`Map exceeds ${ctx.limits.coordinatePositions} coordinate positions.`);
+	return true;
+}
+function id(value, path, ctx) {
+	const text$1 = requiredString(value, path, ctx, ctx.limits.id);
+	if (!text$1) return;
+	if (!SAFE_ID.test(text$1)) ctx.issues.push(`${path} is not a safe id.`);
+	if (ctx.ids.has(text$1)) ctx.issues.push(`${path} must be unique.`);
+	ctx.ids.add(text$1);
+}
+function variant(value, path, ctx) {
+	if (value !== void 0 && !VARIANTS.has(value)) ctx.issues.push(`${path} is invalid.`);
+}
+function optionalString(value, path, ctx) {
+	if (value === void 0) return void 0;
+	return requiredString(value, path, ctx);
+}
+function requiredString(value, path, ctx, max = ctx.limits.string) {
+	if (typeof value !== "string" || value.trim() === "" || value.length > max) {
+		ctx.issues.push(`${path} must be a non-empty bounded string.`);
+		return void 0;
+	}
+	countString(value, path, ctx);
+	return value;
+}
+function countString(value, path, ctx) {
+	if (value.length > ctx.limits.string && !path.endsWith(".id")) ctx.issues.push(`${path} exceeds string limit.`);
+	ctx.strings += value.length;
+	if (ctx.strings > ctx.limits.totalStrings) throw new MapLimitError(`Map exceeds ${ctx.limits.totalStrings} total string characters.`);
+}
+function rejectKeys(value, allowed, path, issues) {
+	for (const key of Object.keys(value)) if (DANGEROUS_KEYS.has(key) || !allowed.has(key)) issues.push(`${path}.${key} is not allowed.`);
+}
+function samePosition(a, b) {
+	return Array.isArray(a) && Array.isArray(b) && a.length === 2 && b.length === 2 && a[0] === b[0] && a[1] === b[1];
+}
+function isScalar(value) {
+	return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function set(...values) {
+	return new Set(values);
+}
+function assertSafeGraph(value) {
+	const active = new Set(), visited = new Set();
+	const walk = (current) => {
+		if (typeof current === "number" && !Number.isFinite(current)) throw new MapDocumentError(["Map values must be finite."]);
+		if (typeof current !== "object" || current === null) return;
+		if (active.has(current)) throw new MapDocumentError(["Map values must not contain cycles."]);
+		if (visited.has(current)) return;
+		if (!Array.isArray(current) && !isPlainObject(current)) throw new MapDocumentError(["Map values must use plain objects."]);
+		if (Array.isArray(current)) {
+			for (let i = 0; i < current.length; i++) if (!Object.hasOwn(current, i)) throw new MapDocumentError(["Map arrays must not be sparse."]);
+		}
+		active.add(current);
+		visited.add(current);
+		for (const key of Object.keys(current)) {
+			if (DANGEROUS_KEYS.has(key)) throw new MapDocumentError([`Dangerous key "${key}" is not allowed.`]);
+			const descriptor = Object.getOwnPropertyDescriptor(current, key);
+			if (!descriptor || descriptor.get || descriptor.set) throw new MapDocumentError(["Map values must not contain accessors."]);
+			walk(descriptor.value);
+		}
+		active.delete(current);
+	};
+	walk(value);
+}
+
+//#endregion
+//#region src/index.ts
+function map(options = {}) {
+	const resolved = resolveMapOptions(options);
+	const outputs = new WeakMap();
+	const rejected = new WeakSet();
+	const render = (node) => {
+		const cached = outputs.get(node);
+		if (cached) return cached;
+		let output;
+		if (!node.complete) output = {
+			kind: "html",
+			html: "<div data-aigui-map-loading=\"\" data-block-type=\"map\"></div>"
+		};
+		else if (rejected.has(node)) output = invalidOutput();
+		else try {
+			const document = parseMapDocument(node.content ?? "");
+			output = renderMap(document, resolved);
+		} catch {
+			output = invalidOutput();
+		}
+		outputs.set(node, output);
+		return output;
+	};
+	return {
+		name: "map",
+		nodeRenderers: { map: render },
+		onASTCommit: (nodes) => {
+			let accepted = false;
+			for (const node of nodes) {
+				if (node.type !== "map" || !node.complete) continue;
+				if (accepted) rejected.add(node);
+				else accepted = true;
+			}
+		},
+		promptSpec: mapPromptSpec(),
+		css: mapCss
+	};
+}
+function invalidOutput() {
+	return {
+		kind: "html",
+		html: "<div data-aigui-map-invalid=\"\" role=\"alert\">Invalid map.</div>"
+	};
+}
+function renderMap(document, options) {
+	return {
+		kind: "element",
+		tag: "section",
+		props: {
+			"data-aigui-map": "",
+			"aria-label": document.ariaLabel ?? "Interactive map"
+		},
+		children: [{
+			kind: "mount",
+			mount: (host) => mountMapDocument(host, document, options)
+		}, mapSummary(document)]
+	};
+}
+function mapSummary(document) {
+	const items = [];
+	for (const layer of document.layers) if (layer.type === "markers") for (const marker of layer.items) items.push(summaryItem(marker.label, marker.description));
+	else if (layer.type === "route" && (layer.label || layer.description)) items.push(summaryItem(layer.label ?? "Route", layer.description));
+	else if (layer.type === "geojson" && layer.labelProperty) for (const feature of layer.data.features) {
+		const value = feature.properties?.[layer.labelProperty];
+		if (value !== void 0 && value !== null) items.push(summaryItem(String(value)));
+	}
+	if (!items.length) items.push(summaryItem("Map data is available in the interactive region."));
+	return {
+		kind: "element",
+		tag: "aside",
+		props: {
+			"data-aigui-map-summary": "",
+			"aria-label": "Map summary"
+		},
+		children: [{
+			kind: "element",
+			tag: "ul",
+			children: items
+		}]
+	};
+}
+function summaryItem(label, description) {
+	return {
+		kind: "element",
+		tag: "li",
+		children: [text(description ? `${label}: ${description}` : label)]
+	};
+}
+function text(value) {
+	return {
+		kind: "html",
+		html: value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&#39;")
+	};
+}
+
+//#endregion
+exports.DEFAULT_MAP_LIMITS = DEFAULT_MAP_LIMITS
+exports.MapDocumentError = MapDocumentError
+exports.MapLimitError = MapLimitError
+exports.map = map
+exports.mapCss = mapCss
+exports.mapPromptSpec = mapPromptSpec
+exports.mountMapDocument = mountMapDocument
+exports.parseMapDocument = parseMapDocument
+exports.resolveMapOptions = resolveMapOptions
+exports.validateMapDocument = validateMapDocument