@wil-works/evoke-charts 0.5.0 → 0.7.0

package/dist/3d.mjs

@@ -0,0 +1,4992 @@
+import { a as staggerProgress, i as prefersReducedMotion, n as clearSeriesPalette, r as _plugin_vue_export_helper_default, t as applySeriesPalette } from "./palette-lwVAltky.js";
+import { _ as shadeColor, a as CHART3D_RAMPS, b as resolveChartPalette, c as CHART_COLORS, d as resolveEasing, f as resolveI18n, g as mixHue, h as lighten, i as CHART3D_PALETTE_IDS, l as easings, m as gradientAt, n as validateOptions3d, o as resolveChartRamp, p as darken, r as CHART3D_PALETTES, s as CHART3D_TYPES, t as chart3dOptionsSchema, u as getTheme, v as toRgba } from "./schema-CM4hKlpc.js";
+import { Fragment, Transition, computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, getCurrentInstance, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, reactive, ref, renderList, renderSlot, shallowRef, toDisplayString, watch, withCtx } from "vue";
+//#region src/3d/core/math3d.js
+function v3add(a, b) {
+	return [
+		a[0] + b[0],
+		a[1] + b[1],
+		a[2] + b[2]
+	];
+}
+function v3sub(a, b) {
+	return [
+		a[0] - b[0],
+		a[1] - b[1],
+		a[2] - b[2]
+	];
+}
+function v3scale(a, s) {
+	return [
+		a[0] * s,
+		a[1] * s,
+		a[2] * s
+	];
+}
+function v3dot(a, b) {
+	return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function v3cross(a, b) {
+	return [
+		a[1] * b[2] - a[2] * b[1],
+		a[2] * b[0] - a[0] * b[2],
+		a[0] * b[1] - a[1] * b[0]
+	];
+}
+function v3len(a) {
+	return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+}
+function v3norm(a) {
+	const l = v3len(a);
+	if (l < 1e-12) return [
+		0,
+		0,
+		0
+	];
+	return [
+		a[0] / l,
+		a[1] / l,
+		a[2] / l
+	];
+}
+/**
+* 矩阵乘法 out = a · b（几何语义：先施加 b 的变换，再施加 a）
+* 列主序下 out[c*4+r] = Σ a[k*4+r] * b[c*4+k]
+*/
+function mat4Multiply(a, b) {
+	const out = new Array(16);
+	for (let c = 0; c < 4; c++) for (let r = 0; r < 4; r++) out[c * 4 + r] = a[r] * b[c * 4] + a[4 + r] * b[c * 4 + 1] + a[8 + r] * b[c * 4 + 2] + a[12 + r] * b[c * 4 + 3];
+	return out;
+}
+/**
+* 透视投影矩阵（右手系，相机看向 -Z）
+* @param {number} fovY 垂直视场角（弧度）
+* @param {number} aspect 宽高比
+*/
+function mat4Perspective(fovY, aspect, near, far) {
+	const f = 1 / Math.tan(fovY / 2);
+	const nf = 1 / (near - far);
+	return [
+		f / aspect,
+		0,
+		0,
+		0,
+		0,
+		f,
+		0,
+		0,
+		0,
+		0,
+		(far + near) * nf,
+		-1,
+		0,
+		0,
+		2 * far * near * nf,
+		0
+	];
+}
+/**
+* 视图矩阵 — 把世界变换到相机空间（相机在原点看向 -Z）
+*/
+function mat4LookAt(eye, center, up) {
+	let z = v3sub(eye, center);
+	z = v3norm(z);
+	if (v3len(z) < 1e-12) z = [
+		0,
+		0,
+		1
+	];
+	let x = v3cross(up, z);
+	if (v3len(x) < 1e-12) {
+		x = v3cross([
+			0,
+			1,
+			0
+		], z);
+		if (v3len(x) < 1e-12) x = v3cross([
+			1,
+			0,
+			0
+		], z);
+	}
+	x = v3norm(x);
+	const y = v3cross(z, x);
+	return [
+		x[0],
+		y[0],
+		z[0],
+		0,
+		x[1],
+		y[1],
+		z[1],
+		0,
+		x[2],
+		y[2],
+		z[2],
+		0,
+		-v3dot(x, eye),
+		-v3dot(y, eye),
+		-v3dot(z, eye),
+		1
+	];
+}
+/** 齐次变换 — 返回未做透视除法的 [x, y, z, w] */
+function transformPoint4(m, p) {
+	return [
+		m[0] * p[0] + m[4] * p[1] + m[8] * p[2] + m[12],
+		m[1] * p[0] + m[5] * p[1] + m[9] * p[2] + m[13],
+		m[2] * p[0] + m[6] * p[1] + m[10] * p[2] + m[14],
+		m[3] * p[0] + m[7] * p[1] + m[11] * p[2] + m[15]
+	];
+}
+/**
+* 裁剪空间 → 屏幕坐标
+*
+* depth 取齐次 w：透视投影下 w 恒等于「相机轴向上的视深」，
+* 这正是画家算法需要的排序键（近处小、远处大），比欧氏距离更适合排序，
+* 且天然处理了透视缩放。
+*
+* w ≤ 0 表示顶点落在相机身后，直接判为不可见 —— 若照常除法则坐标会翻折到
+* 画面另一侧，出现「穿透」的鬼影线条。
+*/
+function projectPoint(mvp, viewport, p) {
+	const c = transformPoint4(mvp, p);
+	const w = c[3];
+	if (!(w > 1e-6) || !Number.isFinite(w)) return {
+		x: NaN,
+		y: NaN,
+		z: NaN,
+		depth: Infinity,
+		visible: false
+	};
+	const inv = 1 / w;
+	const ndcX = c[0] * inv;
+	const ndcY = c[1] * inv;
+	const ndcZ = c[2] * inv;
+	return {
+		x: viewport.x + (ndcX * .5 + .5) * viewport.width,
+		y: viewport.y + (1 - (ndcY * .5 + .5)) * viewport.height,
+		z: ndcZ,
+		depth: w,
+		visible: Number.isFinite(ndcX) && Number.isFinite(ndcY)
+	};
+}
+/** 多边形质心（顶点算术平均，用于深度排序键与法线取点） */
+function polygonCentroid(points) {
+	if (!points.length) return [
+		0,
+		0,
+		0
+	];
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	for (const p of points) {
+		x += p[0];
+		y += p[1];
+		z += p[2];
+	}
+	const n = points.length;
+	return [
+		x / n,
+		y / n,
+		z / n
+	];
+}
+/**
+* 多边形法线（Newell 法）
+* 相比任取两条边的叉乘，Newell 法对非严格平面多边形与顶点缠绕误差更稳，
+* 且顺带给出面积加权的方向 —— 曲面上大量小面片时这点很关键。
+*/
+function polygonNormal(points) {
+	let nx = 0;
+	let ny = 0;
+	let nz = 0;
+	const n = points.length;
+	for (let i = 0; i < n; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % n];
+		nx += (a[1] - b[1]) * (a[2] + b[2]);
+		ny += (a[2] - b[2]) * (a[0] + b[0]);
+		nz += (a[0] - b[0]) * (a[1] + b[1]);
+	}
+	return v3norm([
+		nx,
+		ny,
+		nz
+	]);
+}
+//#endregion
+//#region src/3d/core/camera.js
+/**
+* 轨道相机 — 球坐标环绕 + 拖拽/滚轮/平移/自动旋转
+*
+* 世界为 Z 轴向上，相机始终看向 target，位置由三个量决定：
+*   yaw    方位角（度），从 +X 轴起算、绕 +Z 逆时针为正，取模到 (-180, 180]
+*   pitch  仰角（度），0 为与地面平齐、90 为正上方俯视
+*   distance 相机到 target 的距离（世界单位）
+*
+* 全部控制函数都是**纯函数**：接收相机对象、返回新对象，不改写入参。
+* 组件侧把相机放在 ref 里整体替换即可自然触发响应式，测试也可以直接断言前后快照。
+*/
+var DEG$1 = Math.PI / 180;
+/** 默认相机 — 经典的「左前上方俯视」三轴透视构图 */
+var DEFAULT_CAMERA = {
+	yaw: -52,
+	pitch: 27,
+	distance: 3.6,
+	target: [
+		0,
+		0,
+		.3
+	],
+	fov: 42,
+	minPitch: 2,
+	maxPitch: 88,
+	minDistance: 1.4,
+	maxDistance: 10,
+	autoRotate: false,
+	/** 自动旋转角速度（度/秒），正负决定方向 */
+	autoRotateSpeed: 10,
+	/** 惯性衰减系数：每帧速度乘以 (1 - damping)，0 表示无惯性 */
+	damping: .14
+};
+function clamp(v, min, max) {
+	if (!Number.isFinite(v)) return min;
+	if (v < min) return min;
+	if (v > max) return max;
+	return v;
+}
+/** 角度归一化到 (-180, 180]，避免长时间拖拽后 yaw 无限增长 */
+function normalizeAngle(deg) {
+	if (!Number.isFinite(deg)) return 0;
+	let a = ((deg + 180) % 360 + 360) % 360 - 180;
+	if (a === -180) a = 180;
+	return a;
+}
+function num(value, fallback) {
+	return Number.isFinite(value) ? value : fallback;
+}
+/**
+* 合并用户配置为完整相机对象，并做一次钳制
+* 非法值（NaN / 字符串 / 越界）一律回落默认，保证下游投影不会拿到脏数据
+*/
+function resolveCamera(config) {
+	const c = config && typeof config === "object" ? config : {};
+	const base = { ...DEFAULT_CAMERA };
+	const minPitch = num(c.minPitch, base.minPitch);
+	const maxPitch = num(c.maxPitch, base.maxPitch);
+	const minDistance = num(c.minDistance, base.minDistance);
+	const maxDistance = num(c.maxDistance, base.maxDistance);
+	const target = Array.isArray(c.target) && c.target.length >= 3 ? [
+		num(c.target[0], 0),
+		num(c.target[1], 0),
+		num(c.target[2], 0)
+	] : base.target.slice();
+	return {
+		...base,
+		...c,
+		target,
+		minPitch: Math.min(minPitch, maxPitch),
+		maxPitch: Math.max(minPitch, maxPitch),
+		minDistance: Math.min(minDistance, maxDistance),
+		maxDistance: Math.max(minDistance, maxDistance),
+		yaw: normalizeAngle(num(c.yaw, base.yaw)),
+		pitch: clamp(num(c.pitch, base.pitch), Math.min(minPitch, maxPitch), Math.max(minPitch, maxPitch)),
+		distance: clamp(num(c.distance, base.distance), Math.min(minDistance, maxDistance), Math.max(minDistance, maxDistance)),
+		fov: clamp(num(c.fov, base.fov), 10, 120),
+		autoRotateSpeed: num(c.autoRotateSpeed, base.autoRotateSpeed),
+		damping: clamp(num(c.damping, base.damping), 0, 1)
+	};
+}
+/** 相机在世界空间的位置 */
+function cameraEye(camera) {
+	const yaw = camera.yaw * DEG$1;
+	const pitch = camera.pitch * DEG$1;
+	const cp = Math.cos(pitch);
+	return [
+		camera.target[0] + camera.distance * cp * Math.cos(yaw),
+		camera.target[1] + camera.distance * cp * Math.sin(yaw),
+		camera.target[2] + camera.distance * Math.sin(pitch)
+	];
+}
+/** 相机基向量：right / up 取自视图矩阵的旋转行，forward 为视线方向 */
+function cameraBasis(camera) {
+	const eye = cameraEye(camera);
+	const view = mat4LookAt(eye, camera.target, [
+		0,
+		0,
+		1
+	]);
+	return {
+		eye,
+		right: [
+			view[0],
+			view[4],
+			view[8]
+		],
+		up: [
+			view[1],
+			view[5],
+			view[9]
+		],
+		forward: [
+			-view[2],
+			-view[6],
+			-view[10]
+		]
+	};
+}
+/**
+* 视图 × 投影矩阵
+* near/far 随 distance 联动：距离拉远时近平面同步外推，避免远处几何被近平面裁掉；
+* 贴太近时又不至于让 near 退化成 0 造成深度精度塌陷。
+*/
+function cameraMatrices(camera, viewport) {
+	const eye = cameraEye(camera);
+	const view = mat4LookAt(eye, camera.target, [
+		0,
+		0,
+		1
+	]);
+	const aspect = viewport.height > 0 ? viewport.width / viewport.height : 1;
+	const near = Math.max(.02, camera.distance * .02);
+	const far = camera.distance * 12 + 10;
+	const projection = mat4Perspective(camera.fov * DEG$1, aspect, near, far);
+	return {
+		view,
+		projection,
+		mvp: mat4Multiply(projection, view),
+		eye
+	};
+}
+/** 屏幕一个像素在 target 所在平面上对应的世界长度 — 平移与拾取容差共用 */
+function worldPerPixel(camera, viewport) {
+	if (!(viewport.height > 0)) return 0;
+	return 2 * camera.distance * Math.tan(camera.fov * DEG$1 / 2) / viewport.height;
+}
+/**
+* 拖拽 → 新相机
+* 灵敏度按视口尺寸归一：窄容器里同样的手势不该转得更猛。
+*/
+function orbitBy(camera, dxPixels, dyPixels, viewport) {
+	const perPx = 170 / Math.max(240, Math.min(viewport?.width || 0, viewport?.height || 0) || 480);
+	return resolveCamera({
+		...camera,
+		yaw: camera.yaw - dxPixels * perPx,
+		pitch: camera.pitch + dyPixels * perPx * .8
+	});
+}
+/** 滚轮 / 捏合 → 新相机；factor < 1 拉近 */
+function zoomBy(camera, factor) {
+	const f = Number.isFinite(factor) && factor > 0 ? factor : 1;
+	return resolveCamera({
+		...camera,
+		distance: camera.distance * f
+	});
+}
+/** 滚轮增量 → 缩放因子（指数映射，保证缩放手感线性且永不越界） */
+function wheelZoomFactor(deltaY, speed = .0012) {
+	return Math.exp(clamp(Number.isFinite(deltaY) ? deltaY : 0, -600, 600) * speed);
+}
+/** 平移 → 新相机；target 沿相机的 right/up 平面移动 */
+function panBy(camera, dxPixels, dyPixels, viewport) {
+	const { right, up } = cameraBasis(camera);
+	const scale = worldPerPixel(camera, viewport);
+	const offset = v3add(v3scale(right, -dxPixels * scale), v3scale(up, dyPixels * scale));
+	return resolveCamera({
+		...camera,
+		target: v3add(camera.target, offset)
+	});
+}
+/** 自动旋转一帧；dtMs 为真实经过毫秒，保证不同刷新率下转速一致 */
+function autoRotateBy(camera, dtMs) {
+	const dt = Number.isFinite(dtMs) ? dtMs : 0;
+	return {
+		...camera,
+		yaw: normalizeAngle(camera.yaw + camera.autoRotateSpeed * dt / 1e3)
+	};
+}
+/** 事件载荷：只暴露用户关心的字段，不外泄内部派生量 */
+function cameraPayload(camera) {
+	return {
+		yaw: camera.yaw,
+		pitch: camera.pitch,
+		distance: camera.distance,
+		target: camera.target.slice()
+	};
+}
+/**
+* 依据场景包围盒反解相机距离，让几何刚好落在视口内（autoFit）
+* 用垂直视场角与水平视场角中较小的那个来约束，窄容器里也不会溢出。
+*/
+function fitDistance(bounds, camera, viewport) {
+	if (!bounds || !viewport || !(viewport.width > 0) || !(viewport.height > 0)) return camera.distance;
+	const size = v3sub(bounds.max, bounds.min);
+	const radius = Math.max(.001, .5 * Math.sqrt(size[0] ** 2 + size[1] ** 2 + size[2] ** 2));
+	const fovY = camera.fov * DEG$1;
+	const fovX = 2 * Math.atan(Math.tan(fovY / 2) * (viewport.width / viewport.height));
+	return clamp(radius / Math.sin(Math.min(fovY, fovX) / 2) * 1.05, camera.minDistance, camera.maxDistance);
+}
+/** 立方体 6 个面（顶点按逆时针缠绕，法线朝外）— 柱体着色与背面剔除依赖缠绕方向 */
+function boxFaces(min, max) {
+	const [x0, y0, z0] = min;
+	const [x1, y1, z1] = max;
+	return {
+		bottom: [
+			[
+				x0,
+				y0,
+				z0
+			],
+			[
+				x0,
+				y1,
+				z0
+			],
+			[
+				x1,
+				y1,
+				z0
+			],
+			[
+				x1,
+				y0,
+				z0
+			]
+		],
+		top: [
+			[
+				x0,
+				y0,
+				z1
+			],
+			[
+				x1,
+				y0,
+				z1
+			],
+			[
+				x1,
+				y1,
+				z1
+			],
+			[
+				x0,
+				y1,
+				z1
+			]
+		],
+		front: [
+			[
+				x0,
+				y0,
+				z0
+			],
+			[
+				x1,
+				y0,
+				z0
+			],
+			[
+				x1,
+				y0,
+				z1
+			],
+			[
+				x0,
+				y0,
+				z1
+			]
+		],
+		back: [
+			[
+				x1,
+				y1,
+				z0
+			],
+			[
+				x0,
+				y1,
+				z0
+			],
+			[
+				x0,
+				y1,
+				z1
+			],
+			[
+				x1,
+				y1,
+				z1
+			]
+		],
+		left: [
+			[
+				x0,
+				y1,
+				z0
+			],
+			[
+				x0,
+				y0,
+				z0
+			],
+			[
+				x0,
+				y0,
+				z1
+			],
+			[
+				x0,
+				y1,
+				z1
+			]
+		],
+		right: [
+			[
+				x1,
+				y0,
+				z0
+			],
+			[
+				x1,
+				y1,
+				z0
+			],
+			[
+				x1,
+				y1,
+				z1
+			],
+			[
+				x1,
+				y0,
+				z1
+			]
+		]
+	};
+}
+//#endregion
+//#region src/3d/core/tween.js
+/**
+* 数据补间 — 结构不变、仅数值变化时逐帧插值，避免整图重放进场动画
+*
+* 覆盖四种数据形态：series[].data、pieData[].value、scatterData 三元组、surfaceData.z（或 matrix）。
+* 结构（图型 / 类目 / 系列名 / 数组形状）任何一处变了就不再补间，返回 null 由调用方回退到进场动画。
+* 补间按类目序错峰（stagger > 0 时），与进场动画的错峰同向，数据更新看起来是一道波推过去。
+*/
+/** 取数值（非有限值记 null，插值时空缺侧原样保留） */
+function toNum(v) {
+	const n = Number(v);
+	return Number.isFinite(n) ? n : null;
+}
+function mapDeep(matrix) {
+	return Array.isArray(matrix) ? matrix.map((row) => Array.isArray(row) ? row.map(toNum) : []) : null;
+}
+/** 数据快照 — 只留参与补间的数值字段，避免把 options 整棵拷下来 */
+function captureChart3dData(options) {
+	const o = options && typeof options === "object" ? options : {};
+	const sd = o.surfaceData && typeof o.surfaceData === "object" ? o.surfaceData : null;
+	return {
+		type: o.type,
+		labels: Array.isArray(o.labels) ? o.labels.map(String) : [],
+		series: (Array.isArray(o.series) ? o.series : []).map((s) => ({
+			name: s && s.name !== void 0 ? String(s.name) : "",
+			data: Array.isArray(s && s.data) ? s.data.map(toNum) : []
+		})),
+		pieData: (Array.isArray(o.pieData) ? o.pieData : []).map((d) => ({
+			name: d && d.name !== void 0 ? String(d.name) : "",
+			value: toNum(d && d.value)
+		})),
+		scatter: Array.isArray(o.scatterData) ? o.scatterData.map((p) => Array.isArray(p) ? p.map(toNum) : [toNum(p)]) : null,
+		surface: sd ? mapDeep(sd.z) : mapDeep(o.matrix),
+		surfaceKey: Array.isArray(sd && sd.z) ? "surfaceData" : Array.isArray(o.matrix) ? "matrix" : null
+	};
+}
+function sameList(a, b) {
+	return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+/** 二维矩阵只比形状（数值可以不同，正是补间要抹平的差异） */
+function sameDims(a, b) {
+	if (a === null || b === null) return a === b;
+	if (a.length !== b.length) return false;
+	return a.every((row, i) => Array.isArray(row) && Array.isArray(b[i]) && row.length === b[i].length);
+}
+/** 结构是否一致（一致才允许补间） */
+function sameChart3dShape(a, b) {
+	if (!a || !b || a.type !== b.type) return false;
+	if (!sameList(a.labels, b.labels)) return false;
+	if (a.series.length !== b.series.length) return false;
+	if (!a.series.every((s, i) => s.name === b.series[i].name && s.data.length === b.series[i].data.length)) return false;
+	if (a.pieData.length !== b.pieData.length) return false;
+	if (!a.pieData.every((d, i) => d.name === b.pieData[i].name)) return false;
+	const sa = a.scatter;
+	const sb = b.scatter;
+	if (sa === null !== (sb === null)) return false;
+	if (sa && sb && (sa.length !== sb.length || !sa.every((p, i) => p.length === sb[i].length))) return false;
+	return a.surfaceKey === b.surfaceKey && sameDims(a.surface, b.surface);
+}
+function lerp(from, to, t) {
+	if (from === null || to === null) return to;
+	return from + (to - from) * t;
+}
+/**
+* 逐帧插值出「中间态 options」——以目标 options 为骨架，只替换数值字段
+* @param {object} from captureChart3dData 的快照
+* @param {object} to 目标 options（props.options）
+* @param {number} progress 全局进度（0..1，通常已按 easing 缓动过）
+* @param {number} stagger 错峰占比（沿类目序）
+*/
+function interpolateChart3dOptions(from, to, progress, stagger = 0) {
+	if (!sameChart3dShape(from, captureChart3dData(to))) return null;
+	const cols = Math.max(1, from.labels.length);
+	const itemT = (i) => staggerProgress(progress, i, cols, stagger);
+	const out = { ...to };
+	if (Array.isArray(to.series)) out.series = to.series.map((s, si) => {
+		const old = from.series[si];
+		return {
+			...s,
+			data: (Array.isArray(s.data) ? s.data : []).map((v, i) => lerp(old.data[i], toNum(v), itemT(i)))
+		};
+	});
+	if (Array.isArray(to.pieData)) out.pieData = to.pieData.map((d, i) => {
+		const old = from.pieData[i];
+		return {
+			...d,
+			value: lerp(old.value, toNum(d && d.value), itemT(i))
+		};
+	});
+	if (Array.isArray(to.scatterData) && from.scatter) out.scatterData = to.scatterData.map((p, i) => {
+		const old = from.scatter[i];
+		const t = itemT(i);
+		return (Array.isArray(p) ? p : [p]).map((v, k) => lerp(old[k], toNum(v), t));
+	});
+	if (from.surface && from.surfaceKey) {
+		const target = from.surfaceKey === "surfaceData" ? to.surfaceData : to.matrix;
+		const z = (Array.isArray(target && target.z) ? target.z : Array.isArray(target) ? target : []).map((row, r) => {
+			const oldRow = from.surface[r] || [];
+			const t = itemT(r);
+			return (Array.isArray(row) ? row : []).map((v, c) => lerp(oldRow[c], toNum(v), t));
+		});
+		out[from.surfaceKey] = from.surfaceKey === "surfaceData" ? {
+			...to.surfaceData,
+			z
+		} : z;
+	}
+	return out;
+}
+/** 默认光照：跟随相机的肩后主光（左上前方），保证任意视角都有稳定的立体感 */
+var DEFAULT_LIGHT = {
+	ambient: .56,
+	intensity: .88,
+	follow: true,
+	/** 相机相对光照方向（right, up, back 三分量） */
+	offset: [
+		-.45,
+		.6,
+		.66
+	]
+};
+function createScene() {
+	return {
+		items: [],
+		order: 0
+	};
+}
+function push(scene, item) {
+	item.order = scene.order++;
+	scene.items.push(item);
+	return item;
+}
+/**
+* 面图元
+* @param {Array<Array<number>>} points 世界坐标顶点，逆时针缠绕时法线朝外
+*/
+function addFace(scene, points, options = {}) {
+	if (!Array.isArray(points) || points.length < 3) return null;
+	return push(scene, {
+		kind: "face",
+		layer: options.layer || "data",
+		points,
+		color: options.color || "#888888",
+		alpha: options.alpha,
+		stroke: options.stroke,
+		strokeWidth: options.strokeWidth,
+		/** 关闭光照，用于需要绝对准确色值的面（如语义色标） */
+		flat: !!options.flat,
+		/** 允许剔除背向相机的面；仅在顶点缠绕方向可信时开启 */
+		cull: !!options.cull,
+		/** 双面可见：曲面、带状面必须开，否则从下方看会整片消失 */
+		doubleSided: options.doubleSided !== false ? true : false,
+		/** 实体面：柱体/饼体这类有体积的面，纵深增强（描边、面内渐变）只作用于它们 */
+		solid: !!options.solid,
+		/** 细分曲面面（饼体外弧面等）：光照明暗已足够，不加面内渐变、不描细分缝 */
+		curved: !!options.curved,
+		pickable: options.pickable !== false,
+		meta: options.meta || null,
+		visible: true,
+		depth: 0,
+		screen: null,
+		normal: null,
+		fill: options.color || "#888888"
+	});
+}
+/** 线图元（折线；closed 时首尾相连） */
+function addLine(scene, points, options = {}) {
+	if (!Array.isArray(points) || points.length < 2) return null;
+	return push(scene, {
+		kind: "line",
+		layer: options.layer || "data",
+		points,
+		color: options.color || "#888888",
+		alpha: options.alpha,
+		lineWidth: Number.isFinite(options.lineWidth) ? options.lineWidth : 1.5,
+		dash: options.dash || null,
+		closed: !!options.closed,
+		smooth: !!options.smooth,
+		cull: false,
+		pickable: options.pickable !== false,
+		tolerance: Number.isFinite(options.tolerance) ? options.tolerance : 6,
+		meta: options.meta || null,
+		visible: true,
+		depth: 0,
+		screen: null
+	});
+}
+/** 点图元 */
+function addPoint(scene, position, options = {}) {
+	return push(scene, {
+		kind: "point",
+		layer: options.layer || "data",
+		position,
+		color: options.color || "#888888",
+		alpha: options.alpha,
+		radius: Number.isFinite(options.radius) ? options.radius : 4,
+		/** 拾取半径（像素）：细点/细线需要比视觉更大的命中目标 */
+		pickRadius: Number.isFinite(options.pickRadius) ? options.pickRadius : null,
+		symbol: options.symbol || "circle",
+		stroke: options.stroke,
+		strokeWidth: options.strokeWidth,
+		/** 按视深缩放点半径（透视感），关闭后所有点等大 */
+		depthScale: !!options.depthScale,
+		pickable: options.pickable !== false,
+		meta: options.meta || null,
+		visible: true,
+		depth: 0,
+		screen: null
+	});
+}
+/** 文字图元 — 位置锚定在三维空间，但绘制时永远正向、永远在最上层 */
+function addText(scene, position, text, options = {}) {
+	if (text === null || text === void 0 || text === "") return null;
+	return push(scene, {
+		kind: "text",
+		layer: options.layer || "front",
+		position,
+		text: String(text),
+		color: options.color || "#666666",
+		alpha: options.alpha,
+		fontSize: Number.isFinite(options.fontSize) ? options.fontSize : 11,
+		fontWeight: options.fontWeight || "normal",
+		fontFamily: options.fontFamily || null,
+		align: options.align || "center",
+		baseline: options.baseline || "middle",
+		/** 文字底衬（保证压在网格上也可读） */
+		background: options.background || null,
+		/** 相对锚点的屏幕像素偏移，用于刻度标签外推 */
+		offset: Array.isArray(options.offset) ? options.offset : [0, 0],
+		pickable: false,
+		meta: options.meta || null,
+		visible: true,
+		depth: 0,
+		screen: null
+	});
+}
+/** 立方体六面 — 顶点缠绕已在 camera.boxFaces 中校验为法线朝外，故开启背面剔除 */
+function addBox(scene, faces, options = {}) {
+	const out = [];
+	for (const key of Object.keys(faces)) {
+		const f = addFace(scene, faces[key], {
+			...options,
+			cull: options.cull !== false
+		});
+		if (f) out.push(f);
+	}
+	return out;
+}
+/** 世界空间线段（网格、轴线、投影辅助线共用） */
+function addSegment(scene, a, b, options = {}) {
+	return addLine(scene, [a, b], options);
+}
+/**
+* 解析光照方向 — 返回指向光源的单位向量
+* follow=true 时按相机基向量构造，视角旋转时光影跟着转，形体永远处于受光面；
+* 显式给 direction 时固定在世界上，旋转物体能看到明暗变化（更"物理"，但可能转到暗面）。
+*/
+function resolveLight(lighting, basis) {
+	const cfg = {
+		...DEFAULT_LIGHT,
+		...lighting && typeof lighting === "object" ? lighting : {}
+	};
+	let dir;
+	if (Array.isArray(cfg.direction) && cfg.direction.length >= 3 && v3len(cfg.direction) > 1e-9) dir = v3norm([
+		cfg.direction[0],
+		cfg.direction[1],
+		cfg.direction[2]
+	]);
+	else {
+		const off = Array.isArray(cfg.offset) && cfg.offset.length >= 3 ? cfg.offset : DEFAULT_LIGHT.offset;
+		dir = v3norm(v3add(v3add(v3scale(basis.right, off[0]), v3scale(basis.up, off[1])), v3scale(basis.forward, -off[2])));
+	}
+	return {
+		direction: dir,
+		ambient: Number.isFinite(cfg.ambient) ? cfg.ambient : DEFAULT_LIGHT.ambient,
+		intensity: Number.isFinite(cfg.intensity) ? cfg.intensity : DEFAULT_LIGHT.intensity,
+		flat: !!cfg.flat
+	};
+}
+/**
+* 投影整个场景
+* @param {{items:Array}} scene
+* @param {object} camera 已 resolve 的相机
+* @param {{x:number,y:number,width:number,height:number}} viewport 绘图区
+* @param {{lighting?:object, mvp?:Array, eye?:Array, basis?:object}} options
+* @returns {{items:Array, mvp:Array, eye:Array, light:object, dropped:number}}
+*/
+function projectScene(scene, camera, viewport, options = {}) {
+	const { mvp, eye } = options.mvp && options.eye ? {
+		mvp: options.mvp,
+		eye: options.eye
+	} : cameraMatrices(camera, viewport);
+	const basis = options.basis || {
+		eye,
+		right: [
+			1,
+			0,
+			0
+		],
+		up: [
+			0,
+			1,
+			0
+		],
+		forward: [
+			0,
+			0,
+			-1
+		]
+	};
+	const light = resolveLight(options.lighting, basis);
+	const shade = options.shading !== "flat" && !light.flat;
+	const items = [];
+	let dropped = 0;
+	for (const item of scene.items) {
+		if (item.visible === false) {
+			dropped++;
+			continue;
+		}
+		if (item.kind === "text" || item.kind === "point") {
+			const p = projectPoint(mvp, viewport, item.position);
+			if (!p.visible) {
+				dropped++;
+				continue;
+			}
+			const out = {
+				...item,
+				screen: {
+					x: p.x,
+					y: p.y
+				},
+				depth: p.depth
+			};
+			if (item.kind === "point") out.radius = item.depthScale ? item.radius * Math.max(.35, Math.min(2.4, 3.6 / Math.max(.35, p.depth))) : item.radius;
+			items.push(out);
+			continue;
+		}
+		const screen = [];
+		let sumDepth = 0;
+		let ok = true;
+		for (const p of item.points) {
+			const proj = projectPoint(mvp, viewport, p);
+			if (!proj.visible) {
+				ok = false;
+				break;
+			}
+			screen.push([proj.x, proj.y]);
+			sumDepth += proj.depth;
+		}
+		if (!ok || !screen.length) {
+			dropped++;
+			continue;
+		}
+		const depth = sumDepth / screen.length;
+		const out = {
+			...item,
+			screen,
+			depth
+		};
+		if (item.kind === "face") {
+			const normal = polygonNormal(item.points);
+			const centroid = polygonCentroid(item.points);
+			out.normal = normal;
+			out.centroid = centroid;
+			const toEye = v3norm(v3sub(eye, centroid));
+			out.facing = normal[0] * toEye[0] + normal[1] * toEye[1] + normal[2] * toEye[2];
+			if (item.cull && out.facing <= 0) {
+				out.visible = false;
+				items.push(out);
+				continue;
+			}
+			if (shade) {
+				const lambert = normal[0] * light.direction[0] + normal[1] * light.direction[1] + normal[2] * light.direction[2];
+				const effective = out.facing < 0 ? -lambert : lambert;
+				out.fill = shadeColor(item.color, effective, light);
+			} else out.fill = item.color;
+		}
+		items.push(out);
+	}
+	if (options.depth && typeof options.depth === "object") applyDepthCues(items, options.depth);
+	return {
+		items,
+		mvp,
+		eye,
+		light,
+		dropped
+	};
+}
+/**
+* 纵深增强 — 投影后按视深与「实体面」标记施加三道立体感线索
+*   haze      按数据层视深把颜色向背景色混合（近深远浅的空气透视），文字不参与；
+*   edge      给实体面补一圈同色深描边，形体边界更利落、相邻形体不糊在一起；
+*   gradient  实体面面内顶亮底暗（假 AO），面片更「实心」。
+* 雾化基准取数据层视深范围而非全场景：坐标框/墙体会把范围拉长，压掉数据自身的纵深差。
+*/
+function applyDepthCues(items, depth) {
+	const clamp01 = (v) => Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 0;
+	const haze = clamp01(depth.haze);
+	const edge = clamp01(depth.edge);
+	const gradient = clamp01(depth.gradient);
+	if (haze > 0 && depth.hazeColor) {
+		let minD = Infinity;
+		let maxD = -Infinity;
+		for (const it of items) {
+			if (it.visible === false || it.kind === "text" || it.layer !== "data") continue;
+			if (it.depth < minD) minD = it.depth;
+			if (it.depth > maxD) maxD = it.depth;
+		}
+		const span = maxD - minD;
+		for (const it of items) {
+			if (it.visible === false || it.kind === "text") continue;
+			const t = span > 1e-6 ? (it.depth - minD) / span : 0;
+			if (!(t > 0)) continue;
+			const k = haze * Math.min(1, t);
+			if (it.kind === "face") it.fill = mixHue(it.fill, depth.hazeColor, k);
+			else it.color = mixHue(it.color, depth.hazeColor, k);
+		}
+	}
+	for (const it of items) {
+		if (it.visible === false || it.kind !== "face" || !it.solid || it.curved) continue;
+		if (edge > 0 && !it.stroke) it.stroke = darken(it.fill, edge);
+		if (gradient > 0) it.gradient = gradient;
+	}
+}
+/** 深度排序 — 远 → 近（画家算法）；深度相同时保持建景顺序，避免共面闪烁 */
+function sortByDepth(items) {
+	return items.slice().sort((a, b) => b.depth - a.depth || a.order - b.order);
+}
+/** 按层切分：back 与 front 保持建景顺序，只有 data 层参与深度排序 */
+function partitionByLayer(items) {
+	const back = [];
+	const data = [];
+	const front = [];
+	for (const item of items) {
+		if (item.visible === false) continue;
+		if (item.layer === "back") back.push(item);
+		else if (item.layer === "front") front.push(item);
+		else data.push(item);
+	}
+	return {
+		back,
+		data: sortByDepth(data),
+		front
+	};
+}
+/** 射线法判断点是否在多边形内（屏幕坐标） */
+function pointInPolygon(poly, x, y) {
+	if (!Array.isArray(poly) || poly.length < 3) return false;
+	let inside = false;
+	for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+		const xi = poly[i][0];
+		const yi = poly[i][1];
+		const xj = poly[j][0];
+		const yj = poly[j][1];
+		if (yi === yj) continue;
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+/** 点到线段的距离 */
+function distanceToSegment(px, py, ax, ay, bx, by) {
+	const dx = bx - ax;
+	const dy = by - ay;
+	const lenSq = dx * dx + dy * dy;
+	if (lenSq < 1e-12) return Math.hypot(px - ax, py - ay);
+	let t = ((px - ax) * dx + (py - ay) * dy) / lenSq;
+	t = t < 0 ? 0 : t > 1 ? 1 : t;
+	return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+/** 折线到点的最近距离 */
+function distanceToPolyline(screen, x, y) {
+	let best = Infinity;
+	for (let i = 0; i < screen.length - 1; i++) {
+		const d = distanceToSegment(x, y, screen[i][0], screen[i][1], screen[i + 1][0], screen[i + 1][1]);
+		if (d < best) best = d;
+	}
+	return best;
+}
+/**
+* 拾取 — 返回离相机最近（视深最小）的命中图元
+*
+* 命中优先级刻意做成「先按视深取最近」而非「先看类型」：
+* 柱林里前排柱子的顶面与后排柱子的侧面在屏幕上可能重叠，
+* 只有视深能给出符合直觉的答案（挡住你的那个）。
+*
+* @returns {{meta:any, item:object, distance:number}|null}
+*/
+function pickScene(projected, x, y, options = {}) {
+	if (!projected || !Array.isArray(projected.items)) return null;
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+	const tolerance = Number.isFinite(options.tolerance) ? options.tolerance : 6;
+	let best = null;
+	for (const item of projected.items) {
+		if (item.visible === false || !item.pickable || !item.meta) continue;
+		let distance = Infinity;
+		if (item.kind === "face") {
+			if (!item.screen || !pointInPolygon(item.screen, x, y)) continue;
+			distance = 0;
+		} else if (item.kind === "line") {
+			if (!item.screen || item.screen.length < 2) continue;
+			const d = distanceToPolyline(item.screen, x, y);
+			if (d > tolerance + (Number.isFinite(item.tolerance) ? item.tolerance : 0)) continue;
+			distance = d;
+		} else if (item.kind === "point") {
+			if (!item.screen) continue;
+			const d = Math.hypot(x - item.screen.x, y - item.screen.y);
+			if (d > (Number.isFinite(item.pickRadius) ? item.pickRadius : item.radius) + tolerance) continue;
+			distance = d;
+		} else continue;
+		if (!best || item.depth < best.item.depth - 1e-6 || Math.abs(item.depth - best.item.depth) <= 1e-6 && distance < best.distance) best = {
+			meta: item.meta,
+			item,
+			distance
+		};
+	}
+	return best;
+}
+//#endregion
+//#region src/3d/renderer/draw.js
+/**
+* 绘制层 — 把投影后的图元画到 Canvas 2D 上
+*
+* 三趟绘制顺序（见 scene.partitionByLayer）：
+*   back  网格 / 包围框 / 墙体 —— 建景顺序，不排序（永远垫底）
+*   data  数据几何 —— 视深远 → 近（画家算法）
+*   front 轴线 / 刻度 / 标签 —— 建景顺序，永远压顶
+*
+* 远侧的坐标框棱线与 Z 轴走 back 层：它们位于数据后方，压在顶层会「透」在前排柱体上；
+* 近侧棱线与轴线只有在相机确实落在该棱面外侧时才压顶（见 axes3d 的取边判据），
+* 中轴视角下它只是条侧棱，同样垫底。
+*
+* hover 强调走「描边 + 提亮」而非压暗其余图元：三维场景里图元互相遮挡，
+* 全局压暗会同时压到被遮挡者，视觉归属反而混乱。
+*/
+/** 估算文本宽度（CJK 全宽按字号计，其余按 0.62 折算），与 evoke-charts 同口径 */
+function estimateTextWidth(text, fontSize = 12) {
+	const s = String(text ?? "");
+	let w = 0;
+	for (const ch of s) w += ch.charCodeAt(0) > 255 ? fontSize : fontSize * .62;
+	return w;
+}
+function roundRectPath(ctx, x, y, width, height, radius) {
+	const r = Math.max(0, Math.min(radius, Math.abs(width) / 2, Math.abs(height) / 2));
+	ctx.beginPath();
+	ctx.moveTo(x + r, y);
+	ctx.lineTo(x + width - r, y);
+	ctx.quadraticCurveTo(x + width, y, x + width, y + r);
+	ctx.lineTo(x + width, y + height - r);
+	ctx.quadraticCurveTo(x + width, y + height, x + width - r, y + height);
+	ctx.lineTo(x + r, y + height);
+	ctx.quadraticCurveTo(x, y + height, x, y + height - r);
+	ctx.lineTo(x, y + r);
+	ctx.quadraticCurveTo(x, y, x + r, y);
+	ctx.closePath();
+}
+function applyAlpha(ctx, item, base) {
+	const a = Number.isFinite(item.alpha) ? item.alpha : base;
+	ctx.globalAlpha = Math.max(0, Math.min(1, a));
+}
+function resetAlpha(ctx) {
+	ctx.globalAlpha = 1;
+}
+function fontString(item, theme) {
+	const family = item.fontFamily || theme.fontFamily || "sans-serif";
+	return `${item.fontWeight === "bold" ? "600" : "400"} ${item.fontSize}px ${family}`;
+}
+/** 面填充色：实体面带面内渐变（顶亮底暗的假 AO），其余纯色 */
+function faceFill(ctx, item, emphasized) {
+	const base = emphasized ? lighten(item.fill, .08) : item.fill;
+	const g = Number.isFinite(item.gradient) ? item.gradient : 0;
+	if (!(g > 0) || !item.screen || item.screen.length < 3) return base;
+	let top = Infinity;
+	let bottom = -Infinity;
+	for (const p of item.screen) {
+		if (p[1] < top) top = p[1];
+		if (p[1] > bottom) bottom = p[1];
+	}
+	if (!(bottom - top > 1)) return base;
+	const grad = ctx.createLinearGradient(0, top, 0, bottom);
+	grad.addColorStop(0, lighten(base, g));
+	grad.addColorStop(1, darken(base, g));
+	return grad;
+}
+function drawFace(ctx, item, emphasized) {
+	if (!item.screen || item.screen.length < 3) return;
+	ctx.beginPath();
+	ctx.moveTo(item.screen[0][0], item.screen[0][1]);
+	for (let i = 1; i < item.screen.length; i++) ctx.lineTo(item.screen[i][0], item.screen[i][1]);
+	ctx.closePath();
+	ctx.fillStyle = faceFill(ctx, item, emphasized);
+	applyAlpha(ctx, item, 1);
+	ctx.fill();
+	if (item.stroke || emphasized) {
+		ctx.strokeStyle = item.stroke || lighten(item.fill, -.02);
+		ctx.lineWidth = emphasized ? 1.6 : Number.isFinite(item.strokeWidth) ? item.strokeWidth : 1;
+		ctx.setLineDash([]);
+		ctx.stroke();
+	} else if (item.curved) {
+		ctx.strokeStyle = typeof item.fill === "string" ? item.fill : item.color;
+		ctx.lineWidth = 1;
+		ctx.setLineDash([]);
+		ctx.stroke();
+	}
+	resetAlpha(ctx);
+}
+function drawLine(ctx, item, emphasized) {
+	if (!item.screen || item.screen.length < 2) return;
+	ctx.beginPath();
+	ctx.moveTo(item.screen[0][0], item.screen[0][1]);
+	for (let i = 1; i < item.screen.length; i++) ctx.lineTo(item.screen[i][0], item.screen[i][1]);
+	if (item.closed) ctx.closePath();
+	ctx.strokeStyle = item.color;
+	ctx.lineWidth = emphasized ? item.lineWidth * 1.4 : item.lineWidth;
+	ctx.lineJoin = "round";
+	ctx.lineCap = "round";
+	ctx.setLineDash(Array.isArray(item.dash) ? item.dash : []);
+	applyAlpha(ctx, item, 1);
+	ctx.stroke();
+	ctx.setLineDash([]);
+	resetAlpha(ctx);
+}
+function drawPoint(ctx, item, emphasized) {
+	if (!item.screen) return;
+	const r = emphasized ? item.radius * 1.25 : item.radius;
+	const { x, y } = item.screen;
+	ctx.beginPath();
+	if (item.symbol === "rect") ctx.rect(x - r, y - r, r * 2, r * 2);
+	else if (item.symbol === "diamond") {
+		ctx.moveTo(x, y - r);
+		ctx.lineTo(x + r, y);
+		ctx.lineTo(x, y + r);
+		ctx.lineTo(x - r, y);
+		ctx.closePath();
+	} else if (item.symbol === "triangle") {
+		ctx.moveTo(x, y - r);
+		ctx.lineTo(x + r * .87, y + r * .5);
+		ctx.lineTo(x - r * .87, y + r * .5);
+		ctx.closePath();
+	} else ctx.arc(x, y, r, 0, Math.PI * 2);
+	ctx.fillStyle = item.color;
+	applyAlpha(ctx, item, 1);
+	ctx.fill();
+	if (item.stroke || emphasized) {
+		ctx.strokeStyle = item.stroke || "#ffffff";
+		ctx.lineWidth = emphasized ? 2 : Number.isFinite(item.strokeWidth) ? item.strokeWidth : 1;
+		ctx.setLineDash([]);
+		ctx.stroke();
+	}
+	resetAlpha(ctx);
+}
+function drawText(ctx, item, theme, emphasized) {
+	if (!item.screen) return;
+	const x = item.screen.x + (item.offset ? item.offset[0] : 0);
+	const y = item.screen.y + (item.offset ? item.offset[1] : 0);
+	ctx.font = fontString(item, theme);
+	ctx.textAlign = item.align || "center";
+	ctx.textBaseline = item.baseline || "middle";
+	ctx.setLineDash([]);
+	if (item.background) {
+		const w = estimateTextWidth(item.text, item.fontSize) + 8;
+		const h = item.fontSize + 6;
+		ctx.fillStyle = item.background;
+		roundRectPath(ctx, x - w / 2, y - h / 2, w, h, 3);
+		applyAlpha(ctx, item, 1);
+		ctx.fill();
+		resetAlpha(ctx);
+	}
+	ctx.fillStyle = emphasized ? lighten(item.color, .25) : item.color;
+	applyAlpha(ctx, item, 1);
+	ctx.fillText(item.text, x, y);
+	resetAlpha(ctx);
+}
+function drawItem(ctx, item, emphasized, theme) {
+	if (item.visible === false) return;
+	if (item.kind === "face") drawFace(ctx, item, emphasized);
+	else if (item.kind === "line") drawLine(ctx, item, emphasized);
+	else if (item.kind === "point") drawPoint(ctx, item, emphasized);
+	else if (item.kind === "text") drawText(ctx, item, theme, emphasized);
+}
+/**
+* 绘制整个投影结果
+* @param {CanvasRenderingContext2D} ctx
+* @param {object} projected projectScene 的返回值
+* @param {{hoverKey?:string|null, theme?:object}} options
+*/
+function drawScene(ctx, projected, options = {}) {
+	const theme = options.theme || {};
+	const hoverKey = options.hoverKey || null;
+	const { back, data, front } = partitionByLayer(projected.items);
+	for (const item of back) drawItem(ctx, item, false, theme);
+	for (const item of data) {
+		const key = item.meta && item.meta.key;
+		drawItem(ctx, item, !!key && key === hoverKey, theme);
+	}
+	for (const item of front) drawItem(ctx, item, false, theme);
+}
+/** 背景清屏 — 画布复用帧间必须显式擦除，否则残影叠在半透明面上 */
+function clearCanvas(ctx, width, height, color) {
+	ctx.setTransform(1, 0, 0, 1, 0, 0);
+	ctx.clearRect(0, 0, width, height);
+	if (color) {
+		ctx.fillStyle = color;
+		ctx.fillRect(0, 0, width, height);
+	}
+}
+//#endregion
+//#region src/3d/renderer/shared.js
+function seriesName(s, i) {
+	if (s && s.name !== void 0 && s.name !== null && String(s.name).length) return String(s.name);
+	return `系列 ${i + 1}`;
+}
+/**
+* 归一化 series：补名 / 定色 / 标隐藏，剔除隐藏系列
+* @returns {Array<{__index:number, name:string, data:Array, color:string, raw:object}>}
+*/
+function normalizeSeries(options, theme, hiddenSeries) {
+	const list = Array.isArray(options && options.series) ? options.series : [];
+	const colors = Array.isArray(theme.colors) && theme.colors.length ? theme.colors : ["#888888"];
+	const out = [];
+	for (let i = 0; i < list.length; i++) {
+		const s = list[i] && typeof list[i] === "object" ? list[i] : {};
+		const name = seriesName(s, i);
+		if (hiddenSeries && hiddenSeries.has(name)) continue;
+		out.push({
+			__index: i,
+			name,
+			data: Array.isArray(s.data) ? s.data : [],
+			color: typeof s.color === "string" && s.color ? s.color : colors[i % colors.length],
+			raw: s
+		});
+	}
+	return out;
+}
+/** 饼族数据归一化：剔除非法值、补名、定色、算占比 */
+function normalizePie(options, theme, hiddenSeries) {
+	const raw = Array.isArray(options && options.pieData) ? options.pieData : [];
+	const colors = Array.isArray(theme.colors) && theme.colors.length ? theme.colors : ["#888888"];
+	const items = [];
+	for (let i = 0; i < raw.length; i++) {
+		const d = raw[i] && typeof raw[i] === "object" ? raw[i] : { value: raw[i] };
+		const value = Number(d.value);
+		if (!Number.isFinite(value)) continue;
+		const name = d.name !== void 0 && d.name !== null && String(d.name).length ? String(d.name) : `分项 ${i + 1}`;
+		if (hiddenSeries && hiddenSeries.has(name)) continue;
+		items.push({
+			__index: i,
+			name,
+			value,
+			color: typeof d.color === "string" && d.color ? d.color : colors[i % colors.length],
+			raw: d
+		});
+	}
+	const total = items.reduce((s, d) => s + Math.abs(d.value), 0);
+	for (const d of items) d.percent = total > 0 ? Math.abs(d.value) / total : 0;
+	return {
+		items,
+		total
+	};
+}
+/** 曲面矩阵归一化：支持 {x,y,z} 与裸 matrix 两种入参 */
+function normalizeSurface(options) {
+	const sd = options && typeof options.surfaceData === "object" && options.surfaceData ? options.surfaceData : null;
+	const matrix = sd && Array.isArray(sd.z) ? sd.z : Array.isArray(options && options.matrix) ? options.matrix : [];
+	const rows = matrix.length;
+	let cols = 0;
+	for (const row of matrix) if (Array.isArray(row)) cols = Math.max(cols, row.length);
+	const xValues = sd && Array.isArray(sd.x) && sd.x.length === cols ? sd.x.map((v) => Number(v)) : Array.from({ length: cols }, (_, i) => i);
+	const yValues = sd && Array.isArray(sd.y) && sd.y.length === rows ? sd.y.map((v) => Number(v)) : Array.from({ length: rows }, (_, i) => i);
+	const values = [];
+	for (const row of matrix) {
+		if (!Array.isArray(row)) continue;
+		for (const v of row) {
+			const n = Number(v);
+			if (Number.isFinite(n)) values.push(n);
+		}
+	}
+	return {
+		matrix,
+		rows,
+		cols,
+		xValues,
+		yValues,
+		values
+	};
+}
+/**
+* 纵深增强默认值 — 立体感三件套，0 即关闭
+* haze 景深雾化（远景向背景色混合）/ edge 实体面描边 / gradient 面内渐变（假 AO）
+*/
+var DEPTH_DEFAULTS = {
+	haze: .3,
+	edge: .06,
+	gradient: .08
+};
+/** 进场错峰占比默认值 — 0 即全部同步（柱林/扇区依次生长的幅度按条目数自动摊开） */
+var STAGGER_DEFAULT = .25;
+/** 解析 animation.stagger（0..1），缺省用 STAGGER_DEFAULT */
+function resolveStagger(options) {
+	const cfg = options && typeof options.animation === "object" ? options.animation : {};
+	return Number.isFinite(cfg.stagger) ? Math.max(0, Math.min(1, cfg.stagger)) : STAGGER_DEFAULT;
+}
+/** 解析 depth 配置，缺省即 DEPTH_DEFAULTS，越界钳到 [0,1] */
+function resolveDepth(options) {
+	const cfg = options && typeof options.depth === "object" ? options.depth : {};
+	const pick = (v, fallback) => Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : fallback;
+	return {
+		haze: pick(cfg.haze, DEPTH_DEFAULTS.haze),
+		edge: pick(cfg.edge, DEPTH_DEFAULTS.edge),
+		gradient: pick(cfg.gradient, DEPTH_DEFAULTS.gradient)
+	};
+}
+/** HTML 转义 — tooltip 默认模板必须转义，formatter 返回值由使用方自负 */
+function escapeHtml(s) {
+	return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+/** 图例项 — 按图型取名字清单 */
+function computeLegendItems(options, theme, hiddenSeries) {
+	const type = options && options.type;
+	if (type === "surface3d") return [];
+	if (type === "pie3d") {
+		const { items } = normalizePie(options, theme, hiddenSeries);
+		return items.map((d) => ({
+			name: d.name,
+			color: d.color,
+			hidden: false
+		}));
+	}
+	normalizeSeries(options, theme, hiddenSeries);
+	const all = Array.isArray(options && options.series) ? options.series : [];
+	const colors = Array.isArray(theme.colors) && theme.colors.length ? theme.colors : ["#888888"];
+	return all.map((s, i) => {
+		const name = s && s.name !== void 0 && s.name !== null && String(s.name).length ? String(s.name) : `系列 ${i + 1}`;
+		return {
+			name,
+			color: s && typeof s.color === "string" && s.color || colors[i % colors.length],
+			hidden: hiddenSeries ? hiddenSeries.has(name) : false
+		};
+	});
+}
+/**
+* 图例布局
+* @returns {{items:Array, rows:number, height:number, y:number}}
+*/
+function computeLegendLayout(items, canvasWidth, options, topOffset = 0, bottomOffset = 0) {
+	const cfg = options && options.legend && typeof options.legend === "object" ? options.legend : {};
+	if (cfg.show === false || !items.length) return {
+		items: [],
+		rows: 0,
+		height: 0,
+		y: 0
+	};
+	const gap = Number.isFinite(cfg.itemGap) ? cfg.itemGap : 18;
+	const padding = 12;
+	const avail = Math.max(80, canvasWidth - 24);
+	const measured = items.map((it) => {
+		const textWidth = estimateTextWidth(it.name, 12);
+		return {
+			...it,
+			width: 16 + textWidth
+		};
+	});
+	const rows = [];
+	let row = [];
+	let rowWidth = 0;
+	for (const it of measured) {
+		const add = row.length ? gap + it.width : it.width;
+		if (row.length && rowWidth + add > avail) {
+			rows.push({
+				items: row,
+				width: rowWidth
+			});
+			row = [];
+			rowWidth = 0;
+		}
+		const inc = row.length ? gap + it.width : it.width;
+		row.push(it);
+		rowWidth += inc;
+	}
+	if (row.length) rows.push({
+		items: row,
+		width: rowWidth
+	});
+	const align = cfg.align || "center";
+	const height = rows.length * 22 + (rows.length ? 6 : 0);
+	const position = cfg.position === "bottom" ? "bottom" : "top";
+	const y = position === "top" ? topOffset + 2 : Math.max(topOffset + 2, bottomOffset - height - 2);
+	let index = 0;
+	const laid = [];
+	for (const r of rows) {
+		let x = align === "start" ? padding : align === "end" ? canvasWidth - padding - r.width : (canvasWidth - r.width) / 2;
+		for (const it of r.items) {
+			laid.push({
+				...it,
+				x,
+				y: y + index * 22,
+				width: it.width,
+				height: 16
+			});
+			x += it.width + gap;
+		}
+		index++;
+	}
+	return {
+		items: laid,
+		rows: rows.length,
+		height,
+		y,
+		position
+	};
+}
+/** 命中图例项 */
+function hitLegend(layout, x, y) {
+	if (!layout || !Array.isArray(layout.items)) return null;
+	for (const it of layout.items) if (x >= it.x && x <= it.x + it.width && y >= it.y && y <= it.y + it.height + 6) return it;
+	return null;
+}
+/** 绘制图例（swatch + 文本；隐藏项半透明） */
+function drawLegend(ctx, layout, theme) {
+	if (!layout || !layout.items.length) return;
+	ctx.save();
+	ctx.font = `400 12px ${theme.fontFamily || "sans-serif"}`;
+	ctx.textBaseline = "middle";
+	ctx.textAlign = "left";
+	for (const it of layout.items) {
+		ctx.globalAlpha = it.hidden ? .35 : 1;
+		ctx.fillStyle = it.color;
+		const sy = it.y + it.height / 2 - 5;
+		ctx.beginPath();
+		const r = 2;
+		const sx = it.x;
+		ctx.moveTo(sx + r, sy);
+		ctx.lineTo(sx + 10 - r, sy);
+		ctx.quadraticCurveTo(sx + 10, sy, sx + 10, sy + r);
+		ctx.lineTo(sx + 10, sy + 10 - r);
+		ctx.quadraticCurveTo(sx + 10, sy + 10, sx + 10 - r, sy + 10);
+		ctx.lineTo(sx + r, sy + 10);
+		ctx.quadraticCurveTo(sx, sy + 10, sx, sy + 10 - r);
+		ctx.lineTo(sx, sy + r);
+		ctx.quadraticCurveTo(sx, sy, sx + r, sy);
+		ctx.closePath();
+		ctx.fill();
+		ctx.fillStyle = theme.textColor;
+		ctx.fillText(it.name, it.x + 10 + 6, it.y + it.height / 2 + 1);
+	}
+	ctx.restore();
+}
+/**
+* 连续色标（surface / scatter colorScale 用）
+* 离散色阶取样而非 canvas 渐变 —— 录制 SVG 时纯色矩形可以无损还原
+*/
+function drawColorScale(ctx, spec, theme, canvasWidth, viewport) {
+	if (!spec || !Array.isArray(spec.colors) || spec.colors.length < 2) return;
+	const height = Math.max(60, Math.min(150, viewport.height * .44));
+	const width = 10;
+	const x = canvasWidth - 52;
+	const y = viewport.y + Math.max(0, (viewport.height - height) / 2);
+	const steps = spec.colors.length * 4;
+	const fmt = (v) => {
+		const abs = Math.abs(v);
+		if (abs >= 1e3) return `${Math.round(v / 100) / 10}k`;
+		if (abs >= 10) return String(Math.round(v));
+		return String(Math.round(v * 100) / 100);
+	};
+	ctx.save();
+	ctx.globalAlpha = .92;
+	for (let i = 0; i < steps; i++) {
+		const t = 1 - i / (steps - 1);
+		ctx.fillStyle = gradientAt(spec.colors, t);
+		ctx.fillRect(x, y + i * height / steps, width, height / steps + .6);
+	}
+	ctx.globalAlpha = 1;
+	ctx.strokeStyle = theme.borderColor;
+	ctx.lineWidth = 1;
+	ctx.strokeRect(x + .5, y + .5, width, height);
+	ctx.font = `400 10.5px ${theme.fontFamily || "sans-serif"}`;
+	ctx.fillStyle = theme.textColorSecondary;
+	ctx.textAlign = "left";
+	ctx.textBaseline = "middle";
+	ctx.fillText(fmt(spec.max), x + width + 6, y + 5);
+	ctx.fillText(fmt(spec.min), x + width + 6, y + height - 4);
+	if (spec.label) ctx.fillText(spec.label, x + width + 6, y + height / 2);
+	ctx.restore();
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+//#endregion
+//#region src/3d/core/scale3d.js
+/**
+* 刻度与映射 — nice 刻度生成、线性/带状映射、数值格式化
+*
+* 刻度算法与 evoke-charts 保持同一口径（1 / 2 / 5 / 10 阶梯），
+* 这样同一个数据集在二维图与三维图里落到的刻度值是一致的。
+*/
+/** 过滤出可参与统计的有限数值 */
+function finiteValues(values) {
+	const out = [];
+	for (const v of values || []) if (Number.isFinite(v)) out.push(v);
+	return out;
+}
+/**
+* 数值域
+* @param {boolean} includeZero 柱状语义必须从 0 起算，否则柱高失真
+*/
+function extentOf(values, options = {}) {
+	const nums = finiteValues(values);
+	if (!nums.length) return [0, 1];
+	let min = Math.min(...nums);
+	let max = Math.max(...nums);
+	if (options.includeZero) {
+		min = Math.min(0, min);
+		max = Math.max(0, max);
+	}
+	if (min === max) {
+		if (min === 0) return [0, 1];
+		const pad = Math.abs(min) * .5;
+		return [min - pad, max + pad];
+	}
+	const headroom = Number.isFinite(options.headroom) ? options.headroom : 0;
+	if (headroom > 0) {
+		const span = max - min;
+		min -= span * headroom;
+		max += span * headroom;
+	}
+	return [min, max];
+}
+/** 取整到 1 / 2 / 5 / 10 阶梯 */
+function niceNumber(range, round) {
+	if (!(range > 0) || !Number.isFinite(range)) return 1;
+	const pow = 10 ** Math.floor(Math.log10(range));
+	const f = range / pow;
+	let nf;
+	if (round) {
+		if (f < 1.5) nf = 1;
+		else if (f < 3) nf = 2;
+		else if (f < 7) nf = 5;
+		else nf = 10;
+	} else if (f <= 1) nf = 1;
+	else if (f <= 2) nf = 2;
+	else if (f <= 5) nf = 5;
+	else nf = 10;
+	return nf * pow;
+}
+/**
+* nice 刻度 — 返回覆盖数据域且落在整步长上的刻度序列
+* @returns {{min:number, max:number, step:number, values:number[]}}
+*/
+function niceTicks(min, max, count = 5) {
+	const target = Number.isFinite(count) ? Math.max(2, Math.min(20, Math.round(count))) : 5;
+	let lo = Number.isFinite(min) ? min : 0;
+	let hi = Number.isFinite(max) ? max : 1;
+	if (lo > hi) [lo, hi] = [hi, lo];
+	if (lo === hi) {
+		const pad = Math.abs(lo) * .5 || 1;
+		lo -= pad;
+		hi += pad;
+	}
+	const step = niceNumber(niceNumber(hi - lo, false) / (target - 1), true);
+	const niceMin = Math.floor(lo / step) * step;
+	const niceMax = Math.ceil(hi / step) * step;
+	const span = niceMax - niceMin;
+	const guard = Math.min(400, Math.round(span / step) + 1);
+	const decimals = Math.max(0, Math.min(12, -Math.floor(Math.log10(step))));
+	const values = [];
+	for (let i = 0; i < guard; i++) {
+		const v = niceMin + i * step;
+		if (v > niceMax + step * 1e-9) break;
+		values.push(Number(v.toFixed(decimals)));
+	}
+	if (!values.length) values.push(niceMin, niceMax);
+	return {
+		min: niceMin,
+		max: niceMax,
+		step,
+		values
+	};
+}
+/**
+* 线性映射
+* domain → range，domain 退化为单点时返回常量映射，避免除零把坐标打成 NaN
+*/
+function makeLinearScale(domain, range) {
+	const [d0, d1] = domain;
+	const [r0, r1] = range;
+	const span = d1 - d0;
+	const degenerate = Math.abs(span) < 1e-12;
+	const k = degenerate ? 0 : (r1 - r0) / span;
+	return {
+		domain: [d0, d1],
+		range: [r0, r1],
+		degenerate,
+		map: (v) => Number.isFinite(v) ? r0 + (v - d0) * k : r0,
+		invert: (t) => degenerate ? d0 : d0 + (t - r0) / k
+	};
+}
+/**
+* 带状映射 — 类目轴专用，返回类目中心点与可用带宽
+* paddingRatio 为类目间距占整步长的比例（0 = 紧贴，0.9 = 极稀疏）
+*/
+function makeBandScale(count, range, paddingRatio = .24) {
+	const n = Math.max(0, Math.floor(count) || 0);
+	const [r0, r1] = range;
+	const span = r1 - r0;
+	const step = n > 0 ? span / n : 0;
+	const bandwidth = step * (1 - Math.max(0, Math.min(.95, paddingRatio)));
+	return {
+		count: n,
+		step,
+		bandwidth,
+		range: [r0, r1],
+		center: (i) => r0 + step * (i + .5),
+		/** 反查：给定坐标落在第几个类目；越界返回 -1 */
+		indexAt: (t) => {
+			if (!(step > 0)) return -1;
+			const i = Math.floor((t - r0) / step);
+			return i >= 0 && i < n ? i : -1;
+		},
+		start: (i) => r0 + step * i + (step - bandwidth) / 2
+	};
+}
+/**
+* 数值格式化 — 与 evoke-charts 的 formatValue 同口径
+* @param {{decimals?:number, thousandSeparator?:string|false, prefix?:string, suffix?:string, abbreviate?:boolean}} options
+*/
+function formatNumber(value, options = {}) {
+	if (value === null || value === void 0 || Number.isNaN(value)) return "-";
+	const { decimals = 0, thousandSeparator = ",", prefix = "", suffix = "", abbreviate = false } = options;
+	const num = Number(value);
+	if (!Number.isFinite(num)) return "-";
+	let body;
+	if (abbreviate) {
+		const abs = Math.abs(num);
+		if (abs >= 1e8) body = `${(num / 1e8).toFixed(2)}亿`;
+		else if (abs >= 1e4) body = `${(num / 1e4).toFixed(2)}万`;
+		else if (abs >= 1e3) body = `${(num / 1e3).toFixed(2)}K`;
+		else body = num.toFixed(decimals);
+	} else {
+		const fixed = num.toFixed(decimals);
+		if (!thousandSeparator) body = fixed;
+		else if (decimals === 0) body = fixed.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+		else {
+			const [intPart, decPart] = fixed.split(".");
+			body = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator) + (decPart ? `.${decPart}` : "");
+		}
+	}
+	return `${prefix}${body}${suffix}`;
+}
+/** 依据刻度步长推断合适的小数位，供轴标签使用 */
+function decimalsForStep(step) {
+	if (!(step > 0) || !Number.isFinite(step)) return 0;
+	if (step >= 1) return 0;
+	return Math.min(4, Math.ceil(-Math.log10(step)));
+}
+/** 稀疏化刻度：标签过密时按固定步长抽稀，保证首末刻度始终保留 */
+function thinTicks(values, maxCount) {
+	if (!Array.isArray(values) || values.length <= maxCount) return values;
+	const stride = Math.ceil(values.length / maxCount);
+	const out = values.filter((_, i) => i % stride === 0);
+	const last = values[values.length - 1];
+	if (out[out.length - 1] !== last) out.push(last);
+	return out;
+}
+//#endregion
+//#region src/3d/frame.js
+/**
+* 世界标架 — 数据域到三维世界坐标的归一化
+*
+* 所有笛卡尔类图型共用一个标架：地面是 1×1 的方格，高度上限 Z_HEIGHT。
+* 相机参数因此与数据规模解耦 —— 换一套数据不用重新调视角，
+* 拖拽/缩放的手感在 bar3d / line3d / scatter3d / surface3d 之间完全一致。
+*
+* 世界为 Z 轴向上：X 类目、Y 系列（深度）、Z 数值（高度）。
+*/
+/** 世界地面半宽 */
+var WORLD_HALF = .5;
+/** 世界高度（数据最大刻度映射到这里） */
+var Z_HEIGHT = .62;
+/** 世界包围盒（无顶：盒体只有地面与两片背墙，柱子顶到上刻度线是自然形态） */
+function worldBox() {
+	return {
+		min: [
+			-.5,
+			-.5,
+			0
+		],
+		max: [
+			WORLD_HALF,
+			WORLD_HALF,
+			Z_HEIGHT
+		]
+	};
+}
+/** 数值轴配置解析（min/max 显式指定优先） */
+function valueDomain(values, cfg) {
+	const explicitMin = cfg && Number.isFinite(cfg.min) ? cfg.min : null;
+	const explicitMax = cfg && Number.isFinite(cfg.max) ? cfg.max : null;
+	if (explicitMin !== null && explicitMax !== null) return [explicitMin, explicitMax];
+	const [dMin, dMax] = extentOf(values, { includeZero: !!(cfg && cfg.includeZero) });
+	return [explicitMin !== null ? explicitMin : dMin, explicitMax !== null ? explicitMax : dMax];
+}
+/**
+* 类目轴
+* @returns {{type:'category', labels:string[], scale:object, name:string}}
+*/
+function categoryAxis(labels, worldRange, cfg = {}) {
+	const list = Array.isArray(labels) ? labels.map((l, i) => l == null ? String(i + 1) : String(l)) : [];
+	return {
+		type: "category",
+		labels: list,
+		scale: makeBandScale(list.length, worldRange, Number.isFinite(cfg.padding) ? cfg.padding : .24),
+		name: cfg.name || "",
+		formatter: typeof cfg.formatter === "function" ? cfg.formatter : null
+	};
+}
+/**
+* 数值轴 — 域对齐到 nice 刻度，世界区间首尾对应刻度域首尾
+* @returns {{type:'value', scale:object, ticks:{value:number,label:string}[], min:number, max:number}}
+*/
+function valueAxis(values, worldRange, cfg = {}) {
+	const [dMin, dMax] = valueDomain(values, cfg);
+	const nice = niceTicks(dMin, dMax, Number.isFinite(cfg.ticks) ? cfg.ticks : 5);
+	const scale = makeLinearScale([nice.min, nice.max], worldRange);
+	const decimals = Number.isFinite(cfg.decimals) ? cfg.decimals : decimalsForStep(nice.step);
+	const fmt = typeof cfg.formatter === "function" ? cfg.formatter : (v) => formatNumber(v, {
+		decimals,
+		thousandSeparator: ","
+	});
+	const all = nice.values.map((v) => ({
+		value: v,
+		label: fmt(v)
+	}));
+	return {
+		type: "value",
+		scale,
+		ticks: thinTicks(all, Number.isFinite(cfg.maxTicks) ? cfg.maxTicks : 9),
+		allTicks: all,
+		min: nice.min,
+		max: nice.max,
+		step: nice.step,
+		name: cfg.name || "",
+		formatter: fmt
+	};
+}
+/** 组装笛卡尔标架 */
+function buildFrame(xAxis, yAxis, zAxis, box = worldBox()) {
+	return {
+		x: xAxis,
+		y: yAxis,
+		z: zAxis,
+		box
+	};
+}
+/** 判断值是否缺失（缺失值跳过绘制但保留占位语义） */
+function isMissing(v) {
+	return v === null || v === void 0 || typeof v === "number" && Number.isNaN(v);
+}
+//#endregion
+//#region src/3d/renderer/axes3d.js
+/**
+* 三维坐标框 — 地面网格 / 背墙 / 轴线 / 刻度标签
+*
+* 关键决策：轴线取边跟随相机，背景面则钉死在固定侧。
+*   · 背景面固定在 +Y（背墙）/ -X（侧墙）——跟随相机会让它在旋转中整面跳边；
+*     相机绕到墙背面时整组（面 + 网格 + 顶棱）短距离淡出，避免挡在数据前面
+*   · X/Y 轴线与刻度贴在离相机近的那条底边（标签不与数据重叠）
+*   · Z 轴立在离相机最远的立柱上（不遮挡柱体）
+* 底边棱线与 Z 轴按远近分层：近侧压顶保证轴线清晰，远侧的垫底交还给数据遮挡；
+* 相机不在该棱面外侧时（中轴视角 / 俯视入盒），近侧一样垫底——压顶的前提是它真的在前方。
+* 因此任意视角下坐标框都在「衬托」数据而不是「遮挡」数据，
+* 这是二维轴渲染器照搬不过来、必须重做的一层。
+*
+* 标签防碰撞在屏幕空间做：先把刻度锚点投到屏幕，再贪心丢弃与前一个
+* 标签包围盒重叠的候选。三维里标签间距随视角变化，世界空间的等步长
+* 抽稀无法保证不叠字。
+*/
+/** 按 maxCount 求 stride，保证至少 1 */
+function strideFor$1(count, maxCount) {
+	if (!(count > maxCount) || maxCount < 1) return 1;
+	return Math.ceil(count / maxCount);
+}
+/** 背景面淡出跨度（相机方向余弦）——转过约 20° 即完全退场，避免贴墙时突然消失 */
+var WALL_FADE_SPAN = .35;
+/** 世界方向 → 屏幕像素方向（用于把标签沿「远离盒体」的方向外推） */
+function screenDir(mvp, viewport, from, worldDir, pixelDist) {
+	const eps = .03;
+	const a = projectPoint(mvp, viewport, from);
+	const b = projectPoint(mvp, viewport, [
+		from[0] + worldDir[0] * eps,
+		from[1] + worldDir[1] * eps,
+		from[2] + worldDir[2] * eps
+	]);
+	if (!a.visible || !b.visible) return [0, 0];
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len = Math.hypot(dx, dy);
+	if (len < 1e-9) return [0, 0];
+	return [dx / len * pixelDist, dy / len * pixelDist];
+}
+function rectsOverlap(a, b, pad) {
+	return a.x0 - pad < b.x1 && a.x1 + pad > b.x0 && a.y0 - pad < b.y1 && a.y1 + pad > b.y0;
+}
+/**
+* 带防碰撞的刻度标签装配
+* ticks: [{ world:[x,y,z], label:string }]；逐个投影，贪心丢弃与前一个保留标签重叠者
+*/
+function addAxisLabels(scene, ticks, outDir, options) {
+	const { mvp, viewport, color, fontSize = 11, align, pad = 2, dist = 15, anchor } = options;
+	let last = null;
+	let kept = 0;
+	const rects = [];
+	for (const t of ticks) {
+		const base = anchor ? anchor(t.world) : t.world;
+		const off = screenDir(mvp, viewport, base, outDir, dist);
+		const proj = projectPoint(mvp, viewport, base);
+		if (!proj.visible) continue;
+		const lx = proj.x + off[0];
+		const ly = proj.y + off[1];
+		const w = estimateTextWidth(t.label, fontSize);
+		const rect = {
+			x0: lx - (align === "right" ? w : align === "left" ? 0 : w / 2),
+			x1: lx + (align === "right" ? 0 : align === "left" ? w : w / 2),
+			y0: ly - fontSize * .7,
+			y1: ly + fontSize * .7
+		};
+		if (last && rectsOverlap(rect, last, pad)) continue;
+		last = rect;
+		rects.push(rect);
+		addText(scene, base, t.label, {
+			color,
+			layer: "front",
+			fontSize,
+			offset: [off[0], off[1] - 1],
+			align
+		});
+		kept++;
+	}
+	return rects;
+}
+/**
+* 轴名放置 — 沿外推方向逐步升级距离，与已保留的刻度标签碰撞则退避，
+* 全部撞就放弃（宁可少一个轴名也不叠字）
+*/
+function addAxisName(scene, base, name, outDir, keptRects, options) {
+	if (!name) return;
+	const { mvp, viewport, color, align = "center", dists = [
+		38,
+		54,
+		70
+	] } = options;
+	const proj = projectPoint(mvp, viewport, base);
+	if (!proj.visible) return;
+	const w = estimateTextWidth(name, 11);
+	for (const dist of dists) {
+		const off = screenDir(mvp, viewport, base, outDir, dist);
+		const lx = proj.x + off[0];
+		const ly = proj.y + off[1];
+		const rect = {
+			x0: lx - w / 2,
+			x1: lx + w / 2,
+			y0: ly - 9,
+			y1: ly + 9
+		};
+		if (keptRects.some((r) => rectsOverlap(rect, r, 2))) continue;
+		addText(scene, base, name, {
+			color,
+			layer: "front",
+			fontSize: 11,
+			offset: [off[0], off[1]],
+			align
+		});
+		return;
+	}
+}
+/**
+* 装配三维坐标框（往场景里加 back/front 图元）
+* @param {object} scene 目标场景
+* @param {object} frame buildFrame 的标架
+* @param {object} rc 渲染上下文 { theme, options, mvp, eye, viewport }
+*/
+function buildAxes3d(scene, frame, rc) {
+	const { theme, options, mvp, eye, viewport } = rc;
+	const box = frame.box;
+	const [x0, y0, z0] = box.min;
+	const [x1, y1, z1] = box.max;
+	const cx = (x0 + x1) / 2;
+	const cy = (y0 + y1) / 2;
+	const gridShow = (options.grid && typeof options.grid === "object" ? options.grid : {}).show !== false;
+	const boxCfg = options.box && typeof options.box === "object" ? options.box : {};
+	const boxShow = boxCfg.show !== false;
+	const walls = boxCfg.walls === false ? "none" : boxCfg.walls || "back";
+	const axisCfg = (axis, fallbackName) => {
+		const cfg = axis && typeof axis === "object" ? axis : {};
+		return {
+			show: cfg.show !== false,
+			labels: cfg.labels !== false,
+			grid: cfg.grid !== false,
+			line: cfg.line !== false,
+			name: cfg.name !== void 0 ? cfg.name : fallbackName,
+			titleShow: cfg.title !== void 0 ? !!cfg.title : true
+		};
+	};
+	const xc = axisCfg(options.xAxis, frame.x.name);
+	const yc = axisCfg(options.yAxis, frame.y.name);
+	const zc = axisCfg(options.zAxis, frame.z.name);
+	const nearY = eye[1] > cy ? y1 : y0;
+	const farY = nearY === y1 ? y0 : y1;
+	const nearX = eye[0] > cx ? x1 : x0;
+	const farX = nearX === x1 ? x0 : x1;
+	const nearXFront = nearX === x1 ? eye[0] > x1 : eye[0] < x0;
+	const nearYFront = nearY === y1 ? eye[1] > y1 : eye[1] < y0;
+	const wallY = y1;
+	const wallX = x0;
+	const eyeDir = [
+		eye[0] - cx,
+		eye[1] - cy,
+		eye[2] - (z0 + z1) / 2
+	];
+	const eyeLen = Math.hypot(eyeDir[0], eyeDir[1], eyeDir[2]) || 1;
+	/** 可见度 0..1：frontCos 为相机相对墙面的正视程度（墙面外法线方向的投影距离/视距）。 */
+	const wallVis = (frontCos) => Math.max(0, Math.min(1, frontCos / WALL_FADE_SPAN));
+	const backWallVis = wallVis((wallY - eye[1]) / eyeLen);
+	const sideWallVis = wallVis((eye[0] - wallX) / eyeLen);
+	const gridColor = theme.gridColor;
+	const wallColor = theme.wallColor;
+	const lineColor = theme.borderColor;
+	const tickColor = theme.textColorSecondary;
+	if (boxShow && walls !== "none" && gridShow) {
+		const wantBack = walls === "all" || walls === "back" || walls === true;
+		const wantSide = walls === "all" || walls === "side";
+		if (wantBack && backWallVis > 0) addFace(scene, [
+			[
+				x0,
+				wallY,
+				z0
+			],
+			[
+				x1,
+				wallY,
+				z0
+			],
+			[
+				x1,
+				wallY,
+				z1
+			],
+			[
+				x0,
+				wallY,
+				z1
+			]
+		], {
+			color: wallColor,
+			layer: "back",
+			flat: true,
+			pickable: false,
+			alpha: backWallVis
+		});
+		if (wantSide && sideWallVis > 0) addFace(scene, [
+			[
+				wallX,
+				y0,
+				z0
+			],
+			[
+				wallX,
+				y1,
+				z0
+			],
+			[
+				wallX,
+				y1,
+				z1
+			],
+			[
+				wallX,
+				y0,
+				z1
+			]
+		], {
+			color: wallColor,
+			layer: "back",
+			flat: true,
+			pickable: false,
+			alpha: sideWallVis
+		});
+	}
+	if (gridShow && xc.grid && Array.isArray(frame.x.ticks)) {
+		const ticks = frame.x.ticks;
+		const stride = strideFor$1(ticks.length, 30);
+		for (let i = 0; i < ticks.length; i += stride) {
+			const gx = ticks[i].world;
+			addSegment(scene, [
+				gx,
+				y0,
+				z0
+			], [
+				gx,
+				y1,
+				z0
+			], {
+				color: gridColor,
+				layer: "back",
+				lineWidth: 1,
+				pickable: false
+			});
+		}
+	}
+	if (gridShow && yc.grid && Array.isArray(frame.y.ticks)) {
+		const ticks = frame.y.ticks;
+		const stride = strideFor$1(ticks.length, 30);
+		for (let i = 0; i < ticks.length; i += stride) {
+			const gy = ticks[i].world;
+			addSegment(scene, [
+				x0,
+				gy,
+				z0
+			], [
+				x1,
+				gy,
+				z0
+			], {
+				color: gridColor,
+				layer: "back",
+				lineWidth: 1,
+				pickable: false
+			});
+		}
+	}
+	if (gridShow && zc.grid && Array.isArray(frame.z.ticks) && boxShow && walls !== "none") {
+		const wantBack = walls === "all" || walls === "back" || walls === true;
+		const wantSide = walls === "all" || walls === "side";
+		const backLine = {
+			color: gridColor,
+			layer: "back",
+			lineWidth: 1,
+			pickable: false,
+			alpha: backWallVis
+		};
+		const sideLine = {
+			color: gridColor,
+			layer: "back",
+			lineWidth: 1,
+			pickable: false,
+			alpha: sideWallVis
+		};
+		for (const t of frame.z.ticks) {
+			const gz = t.world;
+			if (wantBack && backWallVis > 0) addSegment(scene, [
+				x0,
+				wallY,
+				gz
+			], [
+				x1,
+				wallY,
+				gz
+			], backLine);
+			if (wantSide && sideWallVis > 0) addSegment(scene, [
+				wallX,
+				y0,
+				gz
+			], [
+				wallX,
+				y1,
+				gz
+			], sideLine);
+		}
+		if (wantBack && backWallVis > 0 && Array.isArray(frame.x.ticks)) {
+			const stride = strideFor$1(frame.x.ticks.length, 30);
+			for (let i = 0; i < frame.x.ticks.length; i += stride) {
+				const gx = frame.x.ticks[i].world;
+				addSegment(scene, [
+					gx,
+					wallY,
+					z0
+				], [
+					gx,
+					wallY,
+					z1
+				], backLine);
+			}
+		}
+		if (wantSide && sideWallVis > 0 && Array.isArray(frame.y.ticks)) {
+			const stride = strideFor$1(frame.y.ticks.length, 30);
+			for (let i = 0; i < frame.y.ticks.length; i += stride) {
+				const gy = frame.y.ticks[i].world;
+				addSegment(scene, [
+					wallX,
+					gy,
+					z0
+				], [
+					wallX,
+					gy,
+					z1
+				], sideLine);
+			}
+		}
+	}
+	if (boxShow && boxCfg.frame !== false) {
+		const nearEdges = [{
+			a: [
+				nearX,
+				y0,
+				z0
+			],
+			b: [
+				nearX,
+				y1,
+				z0
+			],
+			front: nearXFront
+		}, {
+			a: [
+				x0,
+				nearY,
+				z0
+			],
+			b: [
+				x1,
+				nearY,
+				z0
+			],
+			front: nearYFront
+		}];
+		const wallRims = [{
+			a: [
+				wallX,
+				y0,
+				z1
+			],
+			b: [
+				wallX,
+				y1,
+				z1
+			],
+			vis: sideWallVis
+		}, {
+			a: [
+				x0,
+				wallY,
+				z1
+			],
+			b: [
+				x1,
+				wallY,
+				z1
+			],
+			vis: backWallVis
+		}];
+		const farEdges = [
+			[[
+				farX,
+				y0,
+				z0
+			], [
+				farX,
+				y1,
+				z0
+			]],
+			[[
+				x0,
+				farY,
+				z0
+			], [
+				x1,
+				farY,
+				z0
+			]],
+			[[
+				farX,
+				farY,
+				z0
+			], [
+				farX,
+				farY,
+				z1
+			]]
+		];
+		for (const { a, b, front } of nearEdges) addSegment(scene, a, b, {
+			color: lineColor,
+			layer: front ? "front" : "back",
+			lineWidth: 1,
+			pickable: false
+		});
+		for (const { a, b, vis } of wallRims) if (vis > 0) addSegment(scene, a, b, {
+			color: lineColor,
+			layer: "back",
+			lineWidth: 1,
+			pickable: false,
+			alpha: vis
+		});
+		for (const [a, b] of farEdges) addSegment(scene, a, b, {
+			color: lineColor,
+			layer: "back",
+			lineWidth: 1,
+			pickable: false
+		});
+	}
+	const labelColor = tickColor;
+	const axisLineColor = darken(theme.textColorSecondary, .1);
+	if (xc.show && Array.isArray(frame.x.ticks)) {
+		if (xc.line) addSegment(scene, [
+			x0,
+			nearY,
+			z0
+		], [
+			x1,
+			nearY,
+			z0
+		], {
+			color: axisLineColor,
+			layer: nearYFront ? "front" : "back",
+			lineWidth: 1.2,
+			pickable: false
+		});
+		const outDir = [
+			0,
+			nearY === y1 ? 1 : -1,
+			0
+		];
+		let xRects = [];
+		if (xc.labels) xRects = addAxisLabels(scene, frame.x.ticks, outDir, {
+			mvp,
+			viewport,
+			color: labelColor,
+			anchor: (w) => [
+				w,
+				nearY,
+				z0
+			]
+		});
+		if (xc.name && xc.titleShow) addAxisName(scene, [
+			(x0 + x1) / 2,
+			nearY,
+			z0
+		], xc.name, outDir, xRects, {
+			mvp,
+			viewport,
+			color: theme.textColorSecondary
+		});
+	}
+	if (yc.show && Array.isArray(frame.y.ticks)) {
+		if (yc.line) addSegment(scene, [
+			nearX,
+			y0,
+			z0
+		], [
+			nearX,
+			y1,
+			z0
+		], {
+			color: axisLineColor,
+			layer: nearXFront ? "front" : "back",
+			lineWidth: 1.2,
+			pickable: false
+		});
+		const outDir = [
+			nearX === x1 ? 1 : -1,
+			0,
+			0
+		];
+		let yRects = [];
+		if (yc.labels) yRects = addAxisLabels(scene, frame.y.ticks, outDir, {
+			mvp,
+			viewport,
+			color: labelColor,
+			dist: 17,
+			align: outDir[0] < 0 ? "right" : "left",
+			anchor: (w) => [
+				nearX,
+				w,
+				z0
+			]
+		});
+		if (yc.name && yc.titleShow) addAxisName(scene, [
+			nearX,
+			(y0 + y1) / 2,
+			z0
+		], yc.name, outDir, yRects, {
+			mvp,
+			viewport,
+			color: theme.textColorSecondary,
+			align: outDir[0] < 0 ? "right" : "left",
+			dists: [
+				42,
+				58,
+				74
+			]
+		});
+	}
+	if (zc.show && Array.isArray(frame.z.ticks)) {
+		if (zc.line) addSegment(scene, [
+			farX,
+			farY,
+			z0
+		], [
+			farX,
+			farY,
+			z1
+		], {
+			color: axisLineColor,
+			layer: "back",
+			lineWidth: 1.2,
+			pickable: false
+		});
+		const outDir = [
+			farX === x0 ? -1 : 1,
+			farY === y0 ? -1 : 1,
+			0
+		];
+		let zRects = [];
+		if (zc.labels) zRects = addAxisLabels(scene, frame.z.ticks, outDir, {
+			mvp,
+			viewport,
+			color: labelColor,
+			fontSize: 10.5,
+			dist: 18,
+			align: "right",
+			anchor: (w) => [
+				farX,
+				farY,
+				w
+			]
+		});
+		if (zc.name && zc.titleShow) addAxisName(scene, [
+			farX,
+			farY,
+			(z0 + z1) / 2
+		], zc.name, outDir, zRects, {
+			mvp,
+			viewport,
+			color: theme.textColorSecondary,
+			align: "right",
+			dists: [
+				44,
+				60,
+				76
+			]
+		});
+	}
+}
+/**
+* 类目刻度装配 — world 为世界坐标，label 为显示文本
+* 网格与标签共用一份 ticks，保证线与字严格对齐
+*/
+function categoryTicks(axis, maxLabels = 16) {
+	const { scale, labels, formatter } = axis;
+	const out = [];
+	if (!scale || !scale.count) return out;
+	const stride = strideFor$1(scale.count, maxLabels);
+	for (let i = 0; i < scale.count; i += stride) {
+		const raw = labels[i] !== void 0 ? labels[i] : String(i + 1);
+		out.push({
+			index: i,
+			world: scale.center(i),
+			label: formatter ? formatter(raw, i) : raw
+		});
+	}
+	return out;
+}
+/** 数值刻度装配 — 刻度值直接映射到世界坐标 */
+function valueTicks(axis) {
+	if (!axis || !Array.isArray(axis.ticks)) return [];
+	return axis.ticks.map((t) => ({
+		value: t.value,
+		world: axis.scale.map(t.value),
+		label: t.label
+	}));
+}
+//#endregion
+//#region src/3d/renderer/charts/bar3d.js
+/**
+* 三维柱状图 — 类目 × 系列 的柱林
+*
+* X 类目、Y 系列（进深）、Z 数值。柱体是封闭长方体：顶面受主光最亮、
+* 侧面随法线背光渐暗；柱体标记为 solid，纵深增强（描边 / 面内渐变 / 远景雾化）
+* 只作用于实体面，斜切面与曲面不参与。
+* 缺失值跳过（不占位、不出零高柱），零值柱保留（高度为 0 时仍画顶面封口，
+* 避免出现「看穿地面」的破面）。
+*/
+function clamp01(v) {
+	return Number.isFinite(v) ? Math.max(.02, Math.min(1, v)) : .62;
+}
+function buildBar3dScene(rc) {
+	const { options, theme, hiddenSeries, progress } = rc;
+	const scene = createScene();
+	const labels = Array.isArray(options.labels) ? options.labels.map(String) : [];
+	const series = normalizeSeries(options, theme, hiddenSeries);
+	const values = [];
+	for (const s of series) for (const v of s.data) {
+		const n = Number(v);
+		if (Number.isFinite(n)) values.push(n);
+	}
+	const bar = options.bar && typeof options.bar === "object" ? options.bar : {};
+	const frame = buildFrame(categoryAxis(labels, [-WORLD_HALF, WORLD_HALF], {
+		...options.xAxis || {},
+		padding: .24
+	}), categoryAxis(series.map((s) => s.name), [-WORLD_HALF, WORLD_HALF], {
+		...options.yAxis || {},
+		padding: .24
+	}), valueAxis(values, [0, Z_HEIGHT], {
+		includeZero: true,
+		...options.zAxis || {}
+	}));
+	frame.x.ticks = categoryTicks(frame.x);
+	frame.y.ticks = categoryTicks(frame.y);
+	frame.z.ticks = valueTicks(frame.z);
+	buildAxes3d(scene, frame, rc);
+	const xBand = frame.x.scale.bandwidth || .1;
+	const yBand = frame.y.scale.bandwidth || .1;
+	const w = xBand * clamp01(bar.width);
+	const d = yBand * clamp01(bar.depth);
+	const shadow = bar.shadow !== false;
+	const shadowStrength = Number.isFinite(bar.shadowStrength) ? Math.max(0, Math.min(1, bar.shadowStrength)) : .1;
+	const shadowOffset = Array.isArray(bar.shadowOffset) ? [Number(bar.shadowOffset[0]) || 0, Number(bar.shadowOffset[1]) || 0] : [0, 0];
+	const stagger = resolveStagger(options);
+	const cols = frame.x.scale.count;
+	series.forEach((s, si) => {
+		const y0 = frame.y.scale.start(s.__index) + (yBand - d) / 2;
+		const y1 = y0 + d;
+		for (let i = 0; i < frame.x.scale.count; i++) {
+			const v = Number(s.data[i]);
+			if (isMissing(v)) continue;
+			const p = staggerProgress(progress, i, cols, stagger);
+			const x0 = frame.x.scale.start(i) + (xBand - w) / 2;
+			const x1 = x0 + w;
+			const h = Math.max(4e-4, frame.z.scale.map(v) * p);
+			if (shadow && shadowStrength > 0) {
+				const [ox, oy] = shadowOffset;
+				addFace(scene, [
+					[
+						x0 - d * .12 + ox,
+						y0 - d * .12 + oy,
+						.0012
+					],
+					[
+						x1 + d * .12 + ox,
+						y0 - d * .12 + oy,
+						.0012
+					],
+					[
+						x1 + d * .12 + ox,
+						y1 + d * .12 + oy,
+						.0012
+					],
+					[
+						x0 - d * .12 + ox,
+						y1 + d * .12 + oy,
+						.0012
+					]
+				], {
+					color: "#000000",
+					alpha: shadowStrength * p,
+					layer: "back",
+					flat: true,
+					pickable: false
+				});
+			}
+			addBox(scene, boxFaces([
+				x0,
+				y0,
+				0
+			], [
+				x1,
+				y1,
+				h
+			]), {
+				color: s.color,
+				cull: true,
+				solid: true,
+				meta: {
+					key: `bar:${s.__index}:${i}`,
+					type: "bar3d",
+					seriesName: s.name,
+					seriesIndex: s.__index,
+					dataIndex: i,
+					name: labels[i] !== void 0 ? labels[i] : String(i + 1),
+					value: v,
+					color: s.color
+				}
+			});
+		}
+	});
+	return {
+		scene,
+		frame
+	};
+}
+//#endregion
+//#region src/3d/renderer/charts/line3d.js
+/**
+* 三维折线图 — 空间折线 + 落地投影
+*
+* 每条系列是一条悬浮在各自进深层上的空间折线；向下落到地面的虚线投影
+* 与地面投影线解决「一眼看不出高度」的读数问题 —— 三维折线没有共同的
+* 基线参照，投影参照线不是装饰而是必需的读数辅助。
+*/
+function buildLine3dScene(rc) {
+	const { options, theme, hiddenSeries, progress } = rc;
+	const scene = createScene();
+	const labels = Array.isArray(options.labels) ? options.labels.map(String) : [];
+	const series = normalizeSeries(options, theme, hiddenSeries);
+	const values = [];
+	for (const s of series) for (const v of s.data) {
+		const n = Number(v);
+		if (Number.isFinite(n)) values.push(n);
+	}
+	const frame = buildFrame(categoryAxis(labels, [-WORLD_HALF, WORLD_HALF], {
+		...options.xAxis || {},
+		padding: .24
+	}), categoryAxis(series.map((s) => s.name), [-WORLD_HALF, WORLD_HALF], {
+		...options.yAxis || {},
+		padding: .24
+	}), valueAxis(values, [0, Z_HEIGHT], {
+		includeZero: true,
+		...options.zAxis || {}
+	}));
+	frame.x.ticks = categoryTicks(frame.x);
+	frame.y.ticks = categoryTicks(frame.y);
+	frame.z.ticks = valueTicks(frame.z);
+	buildAxes3d(scene, frame, rc);
+	const cfg = options.line && typeof options.line === "object" ? options.line : {};
+	const area = !!cfg.area;
+	const dropLines = cfg.dropLines !== false;
+	const lineWidth = Number.isFinite(cfg.width) ? cfg.width : 2.4;
+	const pointRadius = Number.isFinite(cfg.pointRadius) ? cfg.pointRadius : 3.6;
+	const showPoints = cfg.points !== false;
+	const stagger = resolveStagger(options);
+	const cols = frame.x.scale.count;
+	series.forEach((s) => {
+		const y = frame.y.scale.center(s.__index);
+		const pts = [];
+		for (let i = 0; i < frame.x.scale.count; i++) {
+			const v = Number(s.data[i]);
+			if (isMissing(v)) continue;
+			const p = staggerProgress(progress, i, cols, stagger);
+			pts.push({
+				i,
+				v,
+				prog: p,
+				world: [
+					frame.x.scale.center(i),
+					y,
+					frame.z.scale.map(v) * p
+				]
+			});
+		}
+		if (!pts.length) return;
+		if (dropLines) {
+			for (const p of pts) addSegment(scene, p.world, [
+				p.world[0],
+				p.world[1],
+				.0015
+			], {
+				color: toRgba(s.color, .28 * p.prog),
+				layer: "back",
+				lineWidth: 1,
+				dash: [3, 4],
+				pickable: false
+			});
+			addLine(scene, pts.map((p) => [
+				p.world[0],
+				p.world[1],
+				.0015
+			]), {
+				color: toRgba(s.color, .22),
+				layer: "back",
+				lineWidth: 1.2,
+				pickable: false
+			});
+		}
+		if (area) for (let k = 0; k < pts.length - 1; k++) {
+			const a = pts[k].world;
+			const b = pts[k + 1].world;
+			addFace(scene, [
+				[
+					a[0],
+					a[1],
+					a[2]
+				],
+				[
+					b[0],
+					b[1],
+					b[2]
+				],
+				[
+					b[0],
+					b[1],
+					.002
+				],
+				[
+					a[0],
+					a[1],
+					.002
+				]
+			], {
+				color: s.color,
+				alpha: .2 * progress,
+				layer: "back",
+				flat: true,
+				doubleSided: true,
+				pickable: false
+			});
+		}
+		addLine(scene, pts.map((p) => p.world), {
+			color: s.color,
+			lineWidth,
+			alpha: progress < 1 ? Math.min(1, .25 + progress) : 1,
+			meta: {
+				key: `line:${s.__index}`,
+				type: "line3d",
+				seriesName: s.name,
+				seriesIndex: s.__index,
+				color: s.color,
+				name: s.name,
+				value: null,
+				dataIndex: -1
+			},
+			pickable: false
+		});
+		if (showPoints) pts.forEach((p, k) => {
+			addPoint(scene, p.world, {
+				color: s.color,
+				radius: pointRadius,
+				pickRadius: Math.max(9, pointRadius * 2.4),
+				stroke: theme.isDark ? "rgba(0,0,0,0.35)" : "#ffffff",
+				strokeWidth: 1.2,
+				alpha: Math.min(1, .3 + p.prog),
+				meta: {
+					key: `line:${s.__index}:${p.i}`,
+					type: "line3d",
+					seriesName: s.name,
+					seriesIndex: s.__index,
+					dataIndex: p.i,
+					name: labels[p.i] !== void 0 ? labels[p.i] : String(p.i + 1),
+					value: p.v,
+					color: s.color
+				}
+			});
+		});
+	});
+	return {
+		scene,
+		frame
+	};
+}
+//#endregion
+//#region src/3d/renderer/charts/scatter3d.js
+/**
+* 三维散点图 — 空间点云
+*
+* 两种数据形态自动识别：
+*   · 三元组模式  scatterData / series[].data 为 [x,y,z] —— 三轴全数值
+*   · 类目模式    labels + series[].data 为标量 —— X 类目、Y 系列、Z 数值
+*
+* colorScale 开启后把 Z 值映射到连续色带上（第四维信息编码），
+* 图例区相应换成色标。
+*/
+function isTriple(v) {
+	return Array.isArray(v) && v.length >= 3 && Number.isFinite(Number(v[0])) && Number.isFinite(Number(v[2]));
+}
+function buildScatter3dScene(rc) {
+	const { options, theme, hiddenSeries, progress } = rc;
+	const scene = createScene();
+	const labels = Array.isArray(options.labels) ? options.labels.map(String) : [];
+	const series = normalizeSeries(options, theme, hiddenSeries);
+	const freeData = Array.isArray(options.scatterData) ? options.scatterData.filter(isTriple) : [];
+	const tripleMode = freeData.length > 0 || series.some((s) => s.data.some(isTriple));
+	const cfg = options.scatter && typeof options.scatter === "object" ? options.scatter : {};
+	const baseSize = Number.isFinite(cfg.size) ? cfg.size : 5;
+	const dropLines = cfg.dropLines !== false;
+	const sizeAttenuation = cfg.depthScale !== false;
+	const stagger = resolveStagger(options);
+	let ramp = null;
+	let zDomain = null;
+	let colorScaleOn = false;
+	if (cfg.colorScale) {
+		const rampId = typeof cfg.colorScale === "string" ? cfg.colorScale : "classic";
+		ramp = resolveChartRamp(rampId, theme.isDark) || resolveChartRamp("classic", theme.isDark);
+		colorScaleOn = !!ramp;
+	}
+	let frame;
+	const points = [];
+	if (tripleMode) {
+		const triples = [];
+		series.forEach((s) => {
+			for (const raw of s.data) {
+				if (!isTriple(raw)) continue;
+				triples.push({
+					s,
+					v: [
+						Number(raw[0]),
+						Number(raw[1]),
+						Number(raw[2])
+					]
+				});
+			}
+		});
+		for (const d of freeData) triples.push({
+			s: null,
+			v: d.map(Number)
+		});
+		const xs = triples.map((t) => t.v[0]);
+		const ys = triples.map((t) => t.v[1]);
+		const zs = triples.map((t) => t.v[2]);
+		frame = buildFrame(valueAxis(xs, [-WORLD_HALF, WORLD_HALF], {
+			...options.xAxis || {},
+			headroom: .06
+		}), valueAxis(ys, [-WORLD_HALF, WORLD_HALF], {
+			...options.yAxis || {},
+			headroom: .06
+		}), valueAxis(zs, [0, Z_HEIGHT], {
+			includeZero: false,
+			...options.zAxis || {},
+			headroom: .06
+		}));
+		frame.x.ticks = valueTicks(frame.x);
+		frame.y.ticks = valueTicks(frame.y);
+		frame.z.ticks = valueTicks(frame.z);
+		if (colorScaleOn) zDomain = [Math.min(...zs), Math.max(...zs)];
+		triples.forEach((t, idx) => {
+			const s = t.s;
+			const p = staggerProgress(progress, idx, triples.length, stagger);
+			const zNorm = zDomain && zDomain[1] > zDomain[0] ? (t.v[2] - zDomain[0]) / (zDomain[1] - zDomain[0]) : .5;
+			points.push({
+				prog: p,
+				world: [
+					frame.x.scale.map(t.v[0]),
+					frame.y.scale.map(t.v[1]),
+					frame.z.scale.map(t.v[2]) * p
+				],
+				color: colorScaleOn ? gradientAt(ramp, zNorm) : s ? s.color : theme.colors[0],
+				size: baseSize,
+				meta: {
+					key: `pt:${idx}`,
+					type: "scatter3d",
+					seriesName: s ? s.name : "散点",
+					seriesIndex: s ? s.__index : -1,
+					dataIndex: idx,
+					x: t.v[0],
+					y: t.v[1],
+					z: t.v[2],
+					value: t.v[2],
+					name: null,
+					color: colorScaleOn ? gradientAt(ramp, zNorm) : s ? s.color : theme.colors[0]
+				}
+			});
+		});
+	} else {
+		const values = [];
+		for (const s of series) for (const v of s.data) {
+			const n = Number(v);
+			if (Number.isFinite(n)) values.push(n);
+		}
+		frame = buildFrame(categoryAxis(labels, [-WORLD_HALF, WORLD_HALF], {
+			...options.xAxis || {},
+			padding: .24
+		}), categoryAxis(series.map((s) => s.name), [-WORLD_HALF, WORLD_HALF], {
+			...options.yAxis || {},
+			padding: .24
+		}), valueAxis(values, [0, Z_HEIGHT], {
+			includeZero: true,
+			...options.zAxis || {}
+		}));
+		frame.x.ticks = categoryTicks(frame.x);
+		frame.y.ticks = categoryTicks(frame.y);
+		frame.z.ticks = valueTicks(frame.z);
+		if (colorScaleOn && values.length) zDomain = [Math.min(...values), Math.max(...values)];
+		series.forEach((s) => {
+			const y = frame.y.scale.center(s.__index);
+			for (let i = 0; i < frame.x.scale.count; i++) {
+				const v = Number(s.data[i]);
+				if (isMissing(v)) continue;
+				const p = staggerProgress(progress, i, frame.x.scale.count, stagger);
+				const zNorm = zDomain && zDomain[1] > zDomain[0] ? (v - zDomain[0]) / (zDomain[1] - zDomain[0]) : .5;
+				const color = colorScaleOn ? gradientAt(ramp, zNorm) : s.color;
+				points.push({
+					prog: p,
+					world: [
+						frame.x.scale.center(i),
+						y,
+						frame.z.scale.map(v) * p
+					],
+					color,
+					size: baseSize,
+					meta: {
+						key: `pt:${s.__index}:${i}`,
+						type: "scatter3d",
+						seriesName: s.name,
+						seriesIndex: s.__index,
+						dataIndex: i,
+						name: labels[i] !== void 0 ? labels[i] : String(i + 1),
+						value: v,
+						color
+					}
+				});
+			}
+		});
+	}
+	buildAxes3d(scene, frame, rc);
+	for (const p of points) {
+		if (dropLines) addSegment(scene, p.world, [
+			p.world[0],
+			p.world[1],
+			.0015
+		], {
+			color: toRgba(p.color, .22 * p.prog),
+			layer: "back",
+			lineWidth: 1,
+			dash: [2, 4],
+			pickable: false
+		});
+		addPoint(scene, p.world, {
+			color: p.color,
+			radius: p.size,
+			pickRadius: Math.max(10, p.size * 2.4),
+			depthScale: sizeAttenuation,
+			stroke: theme.isDark ? "rgba(0,0,0,0.3)" : "rgba(255,255,255,0.85)",
+			strokeWidth: 1,
+			alpha: Math.min(1, .35 + p.prog * .65),
+			meta: p.meta
+		});
+	}
+	return {
+		scene,
+		frame,
+		colorScale: colorScaleOn && zDomain ? {
+			min: zDomain[0],
+			max: zDomain[1],
+			colors: ramp,
+			label: options.zAxis && options.zAxis.name || ""
+		} : null
+	};
+}
+//#endregion
+//#region src/3d/renderer/charts/surface3d.js
+/**
+* 三维曲面图 — z = f(x, y) 的高度场
+*
+* 数据为矩阵：行对应 Y、列对应 X，X/Y 走数值轴。
+* 着色按高度走连续色带；面片双面可见，从下方看不会消失。
+*
+* 两个刻意的实现取舍：
+*   · 面片数 O(n²)，矩阵按 MAX_GRID 抽稀，否则几万顶点会拖死交互
+*   · 线框不画整条横/纵线 —— 跨全图的线只有一个质心深度，画家算法会把它
+*     整条画到前景或背景，穿帮明显；拆成逐格短段才能正确参与深度排序
+*/
+/** 单边最大面片数 */
+var MAX_GRID = 48;
+/** 线框抽样上限（单边格数） */
+var MAX_WIRE = 32;
+function strideFor(count, max) {
+	if (!(count > max) || max < 2) return 1;
+	return Math.ceil(count / max);
+}
+function buildSurface3dScene(rc) {
+	const { options, theme, progress } = rc;
+	const scene = createScene();
+	const data = normalizeSurface(options);
+	const cfg = options.surface && typeof options.surface === "object" ? options.surface : {};
+	const rampId = typeof cfg.ramp === "string" ? cfg.ramp : "classic";
+	const ramp = resolveChartRamp(rampId, theme.isDark) || resolveChartRamp("classic", theme.isDark);
+	const wireframe = cfg.wireframe !== false;
+	const opacity = Number.isFinite(cfg.opacity) ? Math.max(.15, Math.min(1, cfg.opacity)) : 1;
+	const rows = data.rows;
+	const cols = data.cols;
+	const empty = !rows || !cols;
+	const rowIdx = decimatedIndices(rows, MAX_GRID);
+	const colIdx = decimatedIndices(cols, MAX_GRID);
+	const cellValues = [];
+	for (const row of data.matrix) {
+		if (!Array.isArray(row)) continue;
+		for (const v of row) {
+			const n = Number(v);
+			if (Number.isFinite(n)) cellValues.push(n);
+		}
+	}
+	const zMin = cellValues.length ? Math.min(...cellValues) : 0;
+	const zMax = cellValues.length ? Math.max(...cellValues) : 1;
+	const frame = buildFrame(valueAxis(data.xValues, [-WORLD_HALF, WORLD_HALF], {
+		...options.xAxis || {},
+		headroom: .01,
+		ticks: 6
+	}), valueAxis(data.yValues, [-WORLD_HALF, WORLD_HALF], {
+		...options.yAxis || {},
+		headroom: .01,
+		ticks: 6
+	}), valueAxis(cellValues, [0, Z_HEIGHT], {
+		includeZero: false,
+		...options.zAxis || {},
+		headroom: .01
+	}));
+	frame.x.ticks = valueTicks(frame.x);
+	frame.y.ticks = valueTicks(frame.y);
+	frame.z.ticks = valueTicks(frame.z);
+	buildAxes3d(scene, frame, rc);
+	if (empty) return {
+		scene,
+		frame,
+		colorScale: null
+	};
+	const xWorld = (i) => frame.x.scale.map(data.xValues[i]);
+	const yWorld = (j) => frame.y.scale.map(data.yValues[j]);
+	const stagger = resolveStagger(options);
+	const grid = [];
+	rowIdx.forEach((j, rj) => {
+		const p = staggerProgress(progress, rj, rowIdx.length, stagger);
+		const line = [];
+		for (const i of colIdx) {
+			const raw = data.matrix[j] ? data.matrix[j][i] : void 0;
+			const v = Number(raw);
+			line.push({
+				x: xWorld(i),
+				y: yWorld(j),
+				z: Number.isFinite(v) ? frame.z.scale.map(v) * p : 0,
+				value: Number.isFinite(v) ? v : null
+			});
+		}
+		grid.push(line);
+	});
+	const norm = (v) => zMax > zMin ? (v - zMin) / (zMax - zMin) : .5;
+	for (let r = 0; r < grid.length - 1; r++) for (let c = 0; c < grid[r].length - 1; c++) {
+		const a = grid[r][c];
+		const b = grid[r][c + 1];
+		const d = grid[r + 1][c + 1];
+		const e = grid[r + 1][c];
+		const vals = [
+			a.value,
+			b.value,
+			d.value,
+			e.value
+		].filter((v) => v !== null);
+		const avg = vals.length ? vals.reduce((s, v) => s + v, 0) / vals.length : zMin;
+		const color = gradientAt(ramp, norm(avg));
+		addFace(scene, [
+			[
+				a.x,
+				a.y,
+				a.z
+			],
+			[
+				b.x,
+				b.y,
+				b.z
+			],
+			[
+				d.x,
+				d.y,
+				d.z
+			],
+			[
+				e.x,
+				e.y,
+				e.z
+			]
+		], {
+			color,
+			flat: true,
+			alpha: opacity,
+			cull: false,
+			doubleSided: true,
+			meta: {
+				key: `sf:${rowIdx[r]}:${colIdx[c]}`,
+				type: "surface3d",
+				seriesName: "曲面",
+				seriesIndex: 0,
+				dataIndex: rowIdx[r] * cols + colIdx[c],
+				x: data.xValues[colIdx[c]],
+				y: data.yValues[rowIdx[r]],
+				value: avg,
+				z: avg,
+				color
+			}
+		});
+	}
+	if (wireframe) {
+		const lineColor = theme.isDark ? "rgba(255,255,255,0.14)" : "rgba(255,255,255,0.45)";
+		const wireRows = decimatedIndices(grid.length, MAX_WIRE);
+		const wireCols = decimatedIndices(grid[0].length, MAX_WIRE);
+		const seg = (p, q) => {
+			addLine(scene, [[
+				p.x,
+				p.y,
+				p.z + .0012
+			], [
+				q.x,
+				q.y,
+				q.z + .0012
+			]], {
+				color: lineColor,
+				lineWidth: .7,
+				alpha: .85,
+				pickable: false
+			});
+		};
+		for (const r of wireRows) {
+			if (r >= grid.length - 1) continue;
+			for (let c = 0; c < grid[r].length - 1; c++) seg(grid[r][c], grid[r][c + 1]);
+		}
+		for (const c of wireCols) {
+			if (c >= grid[0].length - 1) continue;
+			for (let r = 0; r < grid.length - 1; r++) seg(grid[r][c], grid[r + 1][c]);
+		}
+	}
+	return {
+		scene,
+		frame,
+		colorScale: {
+			min: zMin,
+			max: zMax,
+			colors: ramp,
+			label: options.zAxis && options.zAxis.name || ""
+		}
+	};
+}
+/** 0..count-1 的等距下标（首末必含），用于矩阵抽稀 */
+function decimatedIndices(count, max) {
+	const out = [];
+	if (count <= 0) return out;
+	const stride = strideFor(count, max);
+	for (let i = 0; i < count; i += stride) out.push(i);
+	if (out[out.length - 1] !== count - 1) out.push(count - 1);
+	return out;
+}
+//#endregion
+//#region src/3d/renderer/charts/pie3d.js
+/**
+* 三维饼图 / 环形图 — 平放在地面上的厚片圆盘
+*
+* 扇区由五类面构成：顶环面、底环面、外侧弧面、内侧弧面（环形时）、两片径向端面。
+* 所有面的顶点缠绕都已校验为法线朝外，因此整块开启背面剔除。
+* 悬浮扇区整体上浮（z 平移）—— 三维图里「强调」用位移比用变色更可读，
+* 因为面片颜色已被光照调制过，再叠强调色容易失真。
+*/
+var TAU = Math.PI * 2;
+var DEG = Math.PI / 180;
+function clampNum(v, min, max, fallback) {
+	return Number.isFinite(v) ? Math.max(min, Math.min(max, v)) : fallback;
+}
+/** 圆弧采样点 */
+function arcPoints(cx, cy, r, a0, a1, segments, z) {
+	const pts = [];
+	for (let k = 0; k <= segments; k++) {
+		const a = a0 + (a1 - a0) * k / segments;
+		pts.push([
+			cx + Math.cos(a) * r,
+			cy + Math.sin(a) * r,
+			z
+		]);
+	}
+	return pts;
+}
+/** 环形面（外圈逆时针 + 内圈顺时针 → 法线 +Z）；innerRadius 为 0 时退化为整圆 */
+function annulusTop(cx, cy, rOut, rIn, a0, a1, segments, z) {
+	const outer = arcPoints(cx, cy, rOut, a0, a1, segments, z);
+	if (rIn <= 1e-6) return [[
+		cx,
+		cy,
+		z
+	], ...outer];
+	const inner = arcPoints(cx, cy, rIn, a1, a0, segments, z);
+	return [...outer, ...inner];
+}
+function buildPie3dScene(rc) {
+	const { options, theme, hiddenSeries, progress, hoverKey } = rc;
+	const scene = createScene();
+	const { items, total } = normalizePie(options, theme, hiddenSeries);
+	const pie = options.pie && typeof options.pie === "object" ? options.pie : {};
+	const radius = clampNum(pie.radius, .12, .5, .42);
+	const innerRadius = clampNum(pie.innerRadius, 0, radius * .82, 0);
+	const thickness = clampNum(pie.thickness, .02, .5, .18);
+	const startAngle = (Number.isFinite(pie.startAngle) ? pie.startAngle : -90) * DEG;
+	const padAngle = clampNum(pie.padAngle, 0, .12, .01) * DEG;
+	const lift = .055;
+	const shadowOn = pie.shadow !== false;
+	const shadowStrength = Number.isFinite(pie.shadowStrength) ? Math.max(0, Math.min(1, pie.shadowStrength)) : .09;
+	const showLabel = !!(options.label && typeof options.label === "object" ? options.label : {}).show;
+	options.i18n && options.i18n.tooltip && options.i18n.tooltip.percent;
+	const stagger = resolveStagger(options);
+	const sliceCount = items.length;
+	let acc = 0;
+	items.forEach((d, di) => {
+		const p = staggerProgress(progress, di, sliceCount, stagger);
+		const sweepProgress = Math.min(1, p / .85);
+		const thickProgress = Math.max(0, Math.min(1, (p - .1) / .8));
+		const segAngle = d.percent * TAU * sweepProgress;
+		const a0 = startAngle + acc;
+		acc += segAngle;
+		const a1 = startAngle + acc;
+		if (a1 - a0 < 1e-4) return;
+		const gap = Math.min(padAngle, (a1 - a0) * .18);
+		const s0 = a0 + gap / 2;
+		const s1 = a1 - gap / 2;
+		if (s1 - s0 < 1e-4) return;
+		const segments = Math.max(2, Math.ceil((s1 - s0) / (TAU / 72)));
+		const zBase = .0016 + (hoverKey === `pie:${d.__index}` ? lift : 0);
+		const zTop = zBase + thickness * thickProgress;
+		const top = annulusTop(0, 0, radius, innerRadius, s0, s1, segments, zTop);
+		const bottom = annulusTop(0, 0, radius, innerRadius, s1, s0, segments, zBase);
+		const faceOpts = {
+			color: d.color,
+			cull: true,
+			solid: true,
+			doubleSided: false,
+			alpha: Math.min(1, .4 + p * .6),
+			meta: {
+				key: `pie:${d.__index}`,
+				type: "pie3d",
+				seriesName: d.name,
+				seriesIndex: d.__index,
+				dataIndex: d.__index,
+				name: d.name,
+				value: d.value,
+				percent: d.percent,
+				total,
+				color: d.color
+			}
+		};
+		addFace(scene, top, faceOpts);
+		addFace(scene, bottom, faceOpts);
+		const curvedOpts = {
+			...faceOpts,
+			curved: true
+		};
+		const outerA = arcPoints(0, 0, radius, s0, s1, segments, zBase);
+		const outerB = arcPoints(0, 0, radius, s0, s1, segments, zTop);
+		for (let k = 0; k < segments; k++) addFace(scene, [
+			outerA[k],
+			outerA[k + 1],
+			outerB[k + 1],
+			outerB[k]
+		], curvedOpts);
+		if (innerRadius > 1e-6) {
+			const innerA = arcPoints(0, 0, innerRadius, s0, s1, segments, zBase);
+			const innerB = arcPoints(0, 0, innerRadius, s0, s1, segments, zTop);
+			for (let k = 0; k < segments; k++) addFace(scene, [
+				innerB[k],
+				innerB[k + 1],
+				innerA[k + 1],
+				innerA[k]
+			], curvedOpts);
+		}
+		const capStart = [
+			[
+				Math.cos(s0) * innerRadius,
+				Math.sin(s0) * innerRadius,
+				zBase
+			],
+			[
+				Math.cos(s0) * radius,
+				Math.sin(s0) * radius,
+				zBase
+			],
+			[
+				Math.cos(s0) * radius,
+				Math.sin(s0) * radius,
+				zTop
+			],
+			[
+				Math.cos(s0) * innerRadius,
+				Math.sin(s0) * innerRadius,
+				zTop
+			]
+		];
+		const capEnd = [
+			[
+				Math.cos(s1) * innerRadius,
+				Math.sin(s1) * innerRadius,
+				zTop
+			],
+			[
+				Math.cos(s1) * radius,
+				Math.sin(s1) * radius,
+				zTop
+			],
+			[
+				Math.cos(s1) * radius,
+				Math.sin(s1) * radius,
+				zBase
+			],
+			[
+				Math.cos(s1) * innerRadius,
+				Math.sin(s1) * innerRadius,
+				zBase
+			]
+		];
+		addFace(scene, capStart, faceOpts);
+		addFace(scene, capEnd, faceOpts);
+		if (showLabel) {
+			const mid = (s0 + s1) / 2;
+			addText(scene, [
+				Math.cos(mid) * radius * 1.24,
+				Math.sin(mid) * radius * 1.24,
+				zTop
+			], `${d.name} ${(d.percent * 100).toFixed(1)}%`, {
+				layer: "front",
+				fontSize: 11,
+				color: theme.textColorSecondary,
+				align: Math.cos(mid) >= 0 ? "left" : "right",
+				meta: faceOpts.meta,
+				pickable: false
+			});
+		}
+	});
+	const grownH = thickness * Math.max(0, Math.min(1, (progress - .1) / .8));
+	if (shadowOn && shadowStrength > 0 && grownH > .005) addFace(scene, annulusTop(0, 0, radius * 1.05, 0, 0, TAU, 48, 8e-4), {
+		color: "#000000",
+		alpha: shadowStrength,
+		layer: "back",
+		flat: true,
+		pickable: false
+	});
+	return {
+		scene,
+		frame: null,
+		pie: {
+			radius,
+			innerRadius,
+			thickness: grownH
+		}
+	};
+}
+//#endregion
+//#region src/3d/renderer/index.js
+/**
+* 渲染入口 — 装配主题/图例/相机，按 type 分发到图型建景器，投影后绘制
+*
+* 与 evoke-charts 同构的外部契约：render3d(canvas, params) 纯函数式渲染一帧，
+* 返回投影结果与拾取闭包；params.ctx 可注入录制器实现 SVG 导出。
+*
+* 相机决策顺序：resolveCamera(默认 ← options.camera ← params.camera) → autoFit 时按
+* 世界包围盒反解 distance（只调距离不动方位，用户一旦手动交互即由组件关掉 autoFit）。
+* params.camera 是组件实时相机（拖拽/滚轮的结果），优先级最高，否则交互无法出画。
+*/
+var CHART3D_BUILDERS = {
+	bar3d: buildBar3dScene,
+	line3d: buildLine3dScene,
+	scatter3d: buildScatter3dScene,
+	surface3d: buildSurface3dScene,
+	pie3d: buildPie3dScene
+};
+/** 归一化标题配置 */
+function titleInfo(options) {
+	const t = options && options.title;
+	if (!t) return {
+		text: "",
+		subtitle: "",
+		show: false
+	};
+	if (typeof t === "string") return {
+		text: t,
+		subtitle: "",
+		show: true
+	};
+	if (typeof t === "object") return {
+		text: t.text ? String(t.text) : "",
+		subtitle: t.subtitle ? String(t.subtitle) : "",
+		show: t.show !== false && !!(t.text || t.subtitle)
+	};
+	return {
+		text: "",
+		subtitle: "",
+		show: false
+	};
+}
+function titleBlockHeight(options) {
+	const info = titleInfo(options);
+	if (!info.show) return 0;
+	return info.subtitle ? 40 : 26;
+}
+/** 世界包围盒（建景前的确定性估算，供 autoFit） */
+function worldBoundsFor(options) {
+	if (options && options.type === "pie3d") {
+		const pie = options.pie && typeof options.pie === "object" ? options.pie : {};
+		const r = Number.isFinite(pie.radius) ? Math.max(.12, Math.min(.5, pie.radius)) : .42;
+		const t = Number.isFinite(pie.thickness) ? Math.max(.02, Math.min(.5, pie.thickness)) : .18;
+		return {
+			min: [
+				-r,
+				-r,
+				0
+			],
+			max: [
+				r,
+				r,
+				t
+			]
+		};
+	}
+	return {
+		min: [
+			-.5,
+			-.5,
+			0
+		],
+		max: [
+			.5,
+			.5,
+			.62
+		]
+	};
+}
+/** 图型默认相机目标（饼图盘心低、柱体类略高于地面） */
+function defaultTargetFor(type) {
+	return type === "pie3d" ? [
+		0,
+		0,
+		.1
+	] : [
+		0,
+		0,
+		.31
+	];
+}
+/**
+* 预计算 Chrome（标题/图例/内边距/绘图区）—— 建景与绘制共用同一份布局
+*/
+function computeChrome(options, width, height, theme, hiddenSeries) {
+	const legendCfg = options.legend && typeof options.legend === "object" ? options.legend : {};
+	const items = legendCfg.show === false ? [] : computeLegendItems(options, theme, hiddenSeries);
+	const titleH = titleBlockHeight(options);
+	const provisional = computeLegendLayout(items, width, options, titleH + 6, height);
+	const pad = {
+		left: legendCfg.show === false ? 16 : 18,
+		right: 20,
+		top: 6 + titleH,
+		bottom: 14
+	};
+	if (options.type === "surface3d" || options.type === "scatter3d" && !!(options.scatter && options.scatter.colorScale)) pad.right += 48;
+	if (provisional.rows) {
+		if (provisional.position === "bottom") pad.bottom += provisional.height + 6;
+		else pad.top += provisional.height + 4;
+	}
+	return {
+		legend: provisional,
+		legendItems: items,
+		padding: pad,
+		viewport: {
+			x: pad.left,
+			y: pad.top,
+			width: Math.max(20, width - pad.left - pad.right),
+			height: Math.max(20, height - pad.top - pad.bottom)
+		},
+		titleH
+	};
+}
+function drawTitle(ctx, options, theme, width) {
+	const info = titleInfo(options);
+	if (!info.show) return;
+	const cfg = options.title && typeof options.title === "object" ? options.title : {};
+	const x = Number.isFinite(cfg.left) ? cfg.left : 16;
+	ctx.save();
+	ctx.textAlign = "left";
+	ctx.textBaseline = "alphabetic";
+	if (info.text) {
+		ctx.font = `600 13px ${theme.fontFamily || "sans-serif"}`;
+		ctx.fillStyle = theme.textColor;
+		ctx.fillText(info.text, x, 18);
+	}
+	if (info.subtitle) {
+		ctx.font = `400 11px ${theme.fontFamily || "sans-serif"}`;
+		ctx.fillStyle = theme.textColorSecondary;
+		ctx.fillText(info.subtitle, x, info.text ? 34 : 18);
+	}
+	ctx.restore();
+}
+/**
+* 渲染一帧
+* @param {HTMLCanvasElement} canvas
+* @param {object} params { options, dpr, progress, camera, hiddenSeries, hoverKey, theme, ctx, autoFit }
+* @returns {{viewport, camera, projected, legend, colorScale, pickAt, stats, theme}}
+*/
+function render3d(canvas, params) {
+	const options = params && params.options || {};
+	const dpr = params && Number.isFinite(params.dpr) && params.dpr > 0 ? params.dpr : 1;
+	const ctx = params && params.ctx || canvas.getContext("2d");
+	const width = canvas.width / dpr;
+	const height = canvas.height / dpr;
+	const progress = params && Number.isFinite(params.progress) ? Math.max(0, Math.min(1, params.progress)) : 1;
+	const hiddenSeries = params && params.hiddenSeries || /* @__PURE__ */ new Set();
+	const hoverKey = params && params.hoverKey || null;
+	const theme = params && params.theme ? params.theme : getTheme(options, options.theme, resolveChartPalette(options.palette, false));
+	clearCanvas(ctx, canvas.width, canvas.height, theme.backgroundColor);
+	ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+	const chrome = computeChrome(options, width, height, theme, hiddenSeries);
+	const viewport = chrome.viewport;
+	const type = options.type;
+	const builder = CHART3D_BUILDERS[type];
+	if (!builder) return {
+		viewport,
+		camera: null,
+		projected: {
+			items: [],
+			mvp: null,
+			eye: [
+				0,
+				0,
+				0
+			],
+			light: null,
+			dropped: 0
+		},
+		legend: chrome.legend,
+		colorScale: null,
+		pickAt: () => null,
+		stats: {
+			total: 0,
+			unknownType: type
+		},
+		theme
+	};
+	let camera = resolveCamera({
+		target: defaultTargetFor(type),
+		...options.camera && typeof options.camera === "object" ? options.camera : {},
+		...params && params.camera && typeof params.camera === "object" ? params.camera : {}
+	});
+	if (params && params.autoFit) camera = {
+		...camera,
+		distance: fitDistance(worldBoundsFor(options), camera, viewport)
+	};
+	const matrices = cameraMatrices(camera, viewport);
+	const basis = cameraBasis(camera);
+	const built = builder({
+		options,
+		theme,
+		hiddenSeries,
+		progress,
+		hoverKey,
+		mvp: matrices.mvp,
+		eye: matrices.eye,
+		basis,
+		viewport,
+		width,
+		height
+	});
+	const projected = projectScene(built.scene, camera, viewport, {
+		mvp: matrices.mvp,
+		eye: matrices.eye,
+		basis,
+		lighting: options.lighting,
+		depth: {
+			...resolveDepth(options),
+			hazeColor: theme.backdropColor
+		}
+	});
+	drawScene(ctx, projected, {
+		hoverKey,
+		theme
+	});
+	drawTitle(ctx, options, theme, width);
+	drawLegend(ctx, chrome.legend, theme);
+	const scaleRect = built.colorScale ? drawColorScale(ctx, built.colorScale, theme, width, viewport) : null;
+	const stats = {
+		total: projected.items.length,
+		dropped: projected.dropped,
+		pickable: new Set(projected.items.filter((i) => i.pickable && i.meta).map((i) => i.meta.key)).size
+	};
+	return {
+		viewport,
+		camera,
+		projected,
+		legend: chrome.legend,
+		colorScale: built.colorScale ? {
+			...built.colorScale,
+			rect: scaleRect
+		} : null,
+		pickAt: (x, y, tolerance) => pickScene(projected, x, y, { tolerance }),
+		stats,
+		theme
+	};
+}
+//#endregion
+//#region src/3d/chart3d.vue
+var _hoisted_1 = ["tabindex", "aria-label"];
+var _hoisted_2 = {
+	key: 1,
+	class: "ev-chart3d__overlay"
+};
+var _hoisted_3 = {
+	key: 0,
+	class: "ev-chart3d__empty"
+};
+var _hoisted_4 = { class: "ev-chart3d__empty-text" };
+var _hoisted_5 = {
+	key: 0,
+	class: "ev-chart3d__loading"
+};
+var _hoisted_6 = { class: "ev-chart3d__loading-bars" };
+var _hoisted_7 = {
+	key: 0,
+	class: "ev-chart3d__error"
+};
+var _hoisted_8 = { class: "ev-chart3d__error-text" };
+var _hoisted_9 = ["innerHTML"];
+var _hoisted_10 = {
+	class: "ev-chart3d__sr-only",
+	role: "status",
+	"aria-live": "polite"
+};
+/**
+* 三维图表组件 — options 驱动，与 EvChart 同一套使用心智：
+* 同为 options 单 prop、同四态（空/载/错/成）、同令牌与换肤事件、同 BEM 命名族。
+* 差异仅在：交互从「hover 数据」扩展为「轨道视角 + hover 数据」双层。
+*/
+var DRAG_THRESHOLD = 4;
+/** 数据补间：结构不变、仅数值变化时逐帧插值，避免整图重放进场 */
+var INERTIA_MIN_SPEED = .15;
+/** 甩动速度上限（px/ms）：按 damping 0.14 约等于一次 130px 的拖拽余量，再快也不至于甩飞 */
+var INERTIA_MAX_SPEED = 1.2;
+var chart3d_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ Object.assign({ name: "EvChart3d" }, {
+	__name: "chart3d",
+	props: {
+		options: {
+			type: Object,
+			required: true
+		},
+		width: {
+			type: [String, Number],
+			default: "100%"
+		},
+		height: {
+			type: [String, Number],
+			default: 400
+		},
+		responsive: {
+			type: Boolean,
+			default: true
+		},
+		devicePixelRatio: {
+			type: Number,
+			default: void 0
+		}
+	},
+	emits: [
+		"ready",
+		"click",
+		"hover",
+		"unhover",
+		"legend-click",
+		"animation-end",
+		"data-update",
+		"camera-change"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const containerRef = ref(null);
+		const canvasRef = ref(null);
+		const tooltipRef = ref(null);
+		const internalError = ref("");
+		const tooltipVisible = ref(false);
+		const tooltipContent = ref("");
+		const tooltipX = ref(0);
+		const tooltipY = ref(0);
+		const tooltipPlacement = ref("top");
+		const ariaLiveText = ref("");
+		const overlayInfo = reactive({
+			viewport: null,
+			camera: null
+		});
+		const cameraState = shallowRef(null);
+		const lastResult = shallowRef(null);
+		const hiddenSeries = ref(/* @__PURE__ */ new Set());
+		const hoverKey = ref(null);
+		const dpr = computed(() => {
+			if (Number.isFinite(props.devicePixelRatio) && props.devicePixelRatio > 0) return props.devicePixelRatio;
+			try {
+				return typeof window !== "undefined" && window.devicePixelRatio || 1;
+			} catch {
+				return 1;
+			}
+		});
+		const containerStyle = computed(() => {
+			return {
+				width: typeof props.width === "number" ? `${props.width}px` : props.width,
+				height: typeof props.height === "number" ? `${props.height}px` : props.height
+			};
+		});
+		const isEmpty = computed(() => {
+			if (props.options.loading) return false;
+			const o = props.options;
+			const type = o.type;
+			if (type === "pie3d") return !(Array.isArray(o.pieData) ? o.pieData : []).some((d) => {
+				const v = Number(d && d.value);
+				return Number.isFinite(v) && v !== 0;
+			});
+			if (type === "surface3d") {
+				const sd = o.surfaceData && typeof o.surfaceData === "object" ? o.surfaceData : {};
+				return !(Array.isArray(sd.z) ? sd.z : Array.isArray(o.matrix) ? o.matrix : []).some((row) => Array.isArray(row) && row.some((v) => Number.isFinite(Number(v))));
+			}
+			if (type === "scatter3d") {
+				const free = Array.isArray(o.scatterData) && o.scatterData.length > 0;
+				const series = Array.isArray(o.series) ? o.series : [];
+				return !free && !series.some((s) => Array.isArray(s && s.data) && s.data.length > 0);
+			}
+			const labels = Array.isArray(o.labels) ? o.labels : [];
+			return !(Array.isArray(o.series) ? o.series : []).some((s) => Array.isArray(s && s.data) && s.data.length > 0) && !labels.length;
+		});
+		const ariaLabelText = computed(() => `3d-${props.options.type || "chart"}-${props.options.title || ""}`);
+		const emptyText = computed(() => resolveI18n(props.options).noData);
+		function currentTheme() {
+			return getTheme(props.options, props.options.theme, resolveChartPalette(props.options.palette, void 0));
+		}
+		function currentCamera() {
+			return resolveCamera({
+				target: props.options.type === "pie3d" ? [
+					0,
+					0,
+					.1
+				] : [
+					0,
+					0,
+					.31
+				],
+				...props.options.camera || {}
+			});
+		}
+		let renderTimer = null;
+		let animState = null;
+		let animRafId = 0;
+		let autoRafId = 0;
+		let lastAutoTs = 0;
+		let userTouchedCamera = false;
+		let dragState = null;
+		const pointers = /* @__PURE__ */ new Map();
+		let pinchDist = 0;
+		/** 拖拽判定阈值（px）：阈值内的位移算点击手抖，既不转相机也不吞掉点选 */
+		let tweenState = null;
+		let tweenRafId = 0;
+		/** 最近一次出图的数据快照 —— 下一轮更新据此判断能否补间 */
+		let lastData = null;
+		/** 拖拽惯性：松手时记录的速度（px/ms）与拖拽模式，按 damping 衰减滑行 */
+		let inertiaRafId = 0;
+		let inertiaVel = null;
+		let inertiaPan = false;
+		function scheduleRender(delay = 16) {
+			if (renderTimer) clearTimeout(renderTimer);
+			renderTimer = setTimeout(() => {
+				renderTimer = null;
+				render();
+			}, delay);
+		}
+		function sizeCanvas() {
+			const canvas = canvasRef.value;
+			if (!canvas) return null;
+			const rect = containerRef.value ? containerRef.value.getBoundingClientRect() : {
+				width: props.width,
+				height: props.height
+			};
+			const cssW = Math.max(1, Math.round(rect.width || 0));
+			const cssH = Math.max(1, Math.round(rect.height || 0));
+			const deviceW = Math.round(cssW * dpr.value);
+			const deviceH = Math.round(cssH * dpr.value);
+			if (canvas.width !== deviceW || canvas.height !== deviceH) {
+				canvas.width = deviceW;
+				canvas.height = deviceH;
+			}
+			return {
+				cssW,
+				cssH
+			};
+		}
+		function render(optionsOverride) {
+			const canvas = canvasRef.value;
+			if (!canvas || isEmpty.value || internalError.value) return;
+			const options = optionsOverride || tweenState && tweenState.options || props.options;
+			try {
+				if (!sizeCanvas()) return;
+				if (!cameraState.value) cameraState.value = currentCamera();
+				const autoFit = !userTouchedCamera;
+				const result = render3d(canvas, {
+					options,
+					dpr: dpr.value,
+					progress: animState ? animState.progress : 1,
+					camera: cameraState.value,
+					hiddenSeries: hiddenSeries.value,
+					hoverKey: hoverKey.value,
+					theme: currentTheme(),
+					autoFit
+				});
+				if (autoFit && result.camera) cameraState.value = result.camera;
+				lastResult.value = result;
+				overlayInfo.viewport = result.viewport;
+				overlayInfo.camera = result.camera;
+				if (!optionsOverride && !tweenState) lastData = captureChart3dData(props.options);
+			} catch (err) {
+				internalError.value = "渲染失败";
+				if (typeof console !== "undefined") console.error("[EvChart3d] render error:", err);
+			}
+		}
+		function animationConfig() {
+			return props.options.animation && typeof props.options.animation === "object" ? props.options.animation : {};
+		}
+		function stopTween() {
+			if (tweenRafId) {
+				cancelAnimationFrame(tweenRafId);
+				tweenRafId = 0;
+			}
+			tweenState = null;
+		}
+		/** 返回 true 表示这一轮更新由补间接管 */
+		function startTweenIfNeeded() {
+			const cfg = animationConfig();
+			if (cfg.enabled === false || prefersReducedMotion()) return false;
+			if (!lastData) return false;
+			const next = captureChart3dData(props.options);
+			if (!sameChart3dShape(lastData, next)) return false;
+			const from = lastData;
+			const duration = Number.isFinite(cfg.duration) ? Math.max(0, cfg.duration) : 600;
+			const easing = resolveEasing(cfg.easing);
+			const stagger = resolveStagger(props.options);
+			const startTime = Date.now();
+			tweenState = { options: interpolateChart3dOptions(from, props.options, 0, stagger) || props.options };
+			const step = () => {
+				if (!tweenState) return;
+				const t = Math.min(1, (Date.now() - startTime) / Math.max(1, duration));
+				tweenState.options = interpolateChart3dOptions(from, props.options, easing(t), stagger) || props.options;
+				render(tweenState.options);
+				lastData = captureChart3dData(tweenState.options);
+				if (t < 1) tweenRafId = requestAnimationFrame(step);
+				else {
+					tweenRafId = 0;
+					tweenState = null;
+					lastData = captureChart3dData(props.options);
+					emit("animation-end");
+				}
+			};
+			tweenRafId = requestAnimationFrame(step);
+			return true;
+		}
+		function stopInertia() {
+			if (inertiaRafId) {
+				cancelAnimationFrame(inertiaRafId);
+				inertiaRafId = 0;
+			}
+			inertiaVel = null;
+		}
+		function startInertia() {
+			const cam = cameraState.value;
+			const vel = inertiaVel;
+			const panMode = inertiaPan;
+			inertiaVel = null;
+			const damping = cam && Number.isFinite(cam.damping) ? cam.damping : .14;
+			if (!cam || !vel || prefersReducedMotion() || !(damping > 0) || Math.hypot(vel[0], vel[1]) < INERTIA_MIN_SPEED) {
+				ensureAutoRotate();
+				return;
+			}
+			let [vx, vy] = vel;
+			let lastTs = 0;
+			const step = (ts) => {
+				const dt = lastTs ? Math.min(32, ts - lastTs) : 16;
+				lastTs = ts;
+				const decay = Math.pow(1 - damping, dt / 16);
+				vx *= decay;
+				vy *= decay;
+				if (Math.hypot(vx, vy) < .02) {
+					inertiaRafId = 0;
+					if (cameraState.value) emit("camera-change", cameraPayload(cameraState.value));
+					ensureAutoRotate();
+					return;
+				}
+				const viewport = lastResult.value ? lastResult.value.viewport : null;
+				if (cameraState.value) applyCamera(panMode && viewport ? panBy(cameraState.value, vx * dt, vy * dt, viewport) : orbitBy(cameraState.value, vx * dt, vy * dt, viewport), { emitEvent: false });
+				inertiaRafId = requestAnimationFrame(step);
+			};
+			inertiaRafId = requestAnimationFrame(step);
+		}
+		function startEnterAnimation() {
+			stopTween();
+			const cfg = animationConfig();
+			if (cfg.enabled === false || prefersReducedMotion()) {
+				animState = null;
+				render();
+				emit("ready");
+				return;
+			}
+			const duration = Number.isFinite(cfg.duration) ? Math.max(0, cfg.duration) : 600;
+			const easing = resolveEasing(cfg.easing);
+			animState = {
+				startTime: Date.now(),
+				duration,
+				easing,
+				progress: 0
+			};
+			const step = () => {
+				if (!animState) return;
+				const t = Math.min(1, (Date.now() - animState.startTime) / Math.max(1, animState.duration));
+				animState.progress = easing(t);
+				render();
+				if (t < 1) animRafId = requestAnimationFrame(step);
+				else {
+					animState = null;
+					emit("animation-end");
+					emit("ready");
+				}
+			};
+			if (animRafId) cancelAnimationFrame(animRafId);
+			animRafId = requestAnimationFrame(step);
+		}
+		function autoRotateLoop(ts) {
+			autoRafId = 0;
+			const cam = cameraState.value;
+			if (!cam || !cam.autoRotate || dragState) {
+				lastAutoTs = 0;
+				return;
+			}
+			const dt = lastAutoTs ? ts - lastAutoTs : 16;
+			lastAutoTs = ts;
+			applyCamera(autoRotateBy(cam, Math.min(64, dt)), { emitEvent: false });
+			autoRafId = requestAnimationFrame(autoRotateLoop);
+		}
+		function ensureAutoRotate() {
+			if (autoRafId) return;
+			lastAutoTs = 0;
+			autoRafId = requestAnimationFrame(autoRotateLoop);
+		}
+		function stopAutoRotate() {
+			if (autoRafId) {
+				cancelAnimationFrame(autoRafId);
+				autoRafId = 0;
+			}
+		}
+		function applyCamera(next, options = {}) {
+			cameraState.value = next;
+			if (options.emitEvent !== false) emit("camera-change", cameraPayload(next));
+			if (options.autoRotate) ensureAutoRotate();
+			render();
+		}
+		function resetCamera(options = {}) {
+			stopInertia();
+			const cfg = props.options.camera && typeof props.options.camera === "object" ? props.options.camera : {};
+			userTouchedCamera = options.keepAutoFit !== true && Number.isFinite(cfg.distance);
+			applyCamera(currentCamera());
+		}
+		function canvasPoint(evt) {
+			const canvas = canvasRef.value;
+			if (!canvas) return null;
+			const rect = canvas.getBoundingClientRect();
+			return {
+				x: evt.clientX - rect.left,
+				y: evt.clientY - rect.top
+			};
+		}
+		function formatTooltipValue(v) {
+			const vf = props.options.tooltip && props.options.tooltip.valueFormatter;
+			if (typeof vf === "function") return vf(v);
+			const abs = Math.abs(Number(v));
+			if (Number.isFinite(abs) && abs >= 1e4) return formatNumber(Number(v), { abbreviate: true });
+			return formatNumber(Number(v), { decimals: Number.isFinite(Number(v)) && Number(v) % 1 !== 0 ? 2 : 0 });
+		}
+		function buildTooltipRows(meta) {
+			const i18n = resolveI18n(props.options);
+			const rows = [];
+			const push = (name, value, color) => rows.push({
+				name,
+				value,
+				color
+			});
+			if (meta.type === "scatter3d" && meta.name === null) {
+				push(i18n.tooltip.x, formatTooltipValue(meta.x), meta.color);
+				push(i18n.tooltip.y, formatTooltipValue(meta.y), meta.color);
+				push(i18n.tooltip.z, formatTooltipValue(meta.z), meta.color);
+				return rows;
+			}
+			if (meta.type === "surface3d") {
+				push(i18n.tooltip.x, String(meta.x), meta.color);
+				push(i18n.tooltip.y, String(meta.y), meta.color);
+				push(i18n.tooltip.value, formatTooltipValue(meta.value), meta.color);
+				return rows;
+			}
+			if (meta.type === "pie3d") {
+				push(meta.name, formatTooltipValue(meta.value), meta.color);
+				push(i18n.tooltip.percent, `${(meta.percent * 100).toFixed(1)}%`, meta.color);
+				return rows;
+			}
+			push(meta.seriesName, formatTooltipValue(meta.value), meta.color);
+			return rows;
+		}
+		function updateTooltip(hit, cx, cy) {
+			const cfg = props.options.tooltip && typeof props.options.tooltip === "object" ? props.options.tooltip : {};
+			if (cfg.show === false || !hit) {
+				tooltipVisible.value = false;
+				tooltipContent.value = "";
+				return;
+			}
+			const formatter = cfg.formatter;
+			tooltipContent.value = typeof formatter === "function" ? String(formatter(hit.meta) ?? "") : buildTooltipHtml(hit.meta);
+			tooltipVisible.value = !!tooltipContent.value;
+			positionTooltip(cx, cy);
+		}
+		function buildTooltipHtml(meta) {
+			const rows = buildTooltipRows(meta);
+			const title = meta.name !== null && meta.name !== void 0 ? meta.name : meta.seriesName;
+			let html = "";
+			if (title) html += `<div class="ev-chart3d__tooltip-title">${escapeHtml(title)}</div>`;
+			for (const row of rows) html += `<div class="ev-chart3d__tooltip-item"><span class="ev-chart3d__tooltip-dot" style="background:${escapeHtml(row.color || "#888")}"></span><span class="ev-chart3d__tooltip-name">${escapeHtml(row.name)}</span><span class="ev-chart3d__tooltip-value">${escapeHtml(row.value)}</span></div>`;
+			return html;
+		}
+		function positionTooltip(cx, cy) {
+			const container = containerRef.value;
+			if (!container) return;
+			const rect = container.getBoundingClientRect();
+			const tip = tooltipRef.value;
+			const tipW = tip ? tip.offsetWidth : 120;
+			const tipH = tip ? tip.offsetHeight : 40;
+			const gap = 12;
+			let x = cx + gap;
+			let y = cy - tipH - gap;
+			if (x + tipW > rect.width - 4) x = cx - tipW - gap;
+			if (x < 4) x = 4;
+			if (y < 4) y = cy + gap;
+			if (y + tipH > rect.height - 4 && y - tipH - 24 >= 4) y = rect.height - tipH - 4;
+			tooltipX.value = x;
+			tooltipY.value = y;
+			tooltipPlacement.value = "top";
+		}
+		const tooltipStyle = computed(() => ({
+			left: `${tooltipX.value}px`,
+			top: `${tooltipY.value}px`
+		}));
+		function setHover(key, hit, cx, cy) {
+			const changed = key !== hoverKey.value;
+			if (!hit && hoverKey.value) {
+				hoverKey.value = null;
+				tooltipVisible.value = false;
+				ariaLiveText.value = "";
+				emit("unhover");
+				render();
+				return;
+			}
+			if (!hit) return;
+			hoverKey.value = key;
+			if (changed) {
+				ariaLiveText.value = describeHit(hit.meta);
+				emit("hover", {
+					...hit.meta,
+					x: cx,
+					y: cy
+				});
+			}
+			updateTooltip(hit, cx, cy);
+			if (changed) render();
+		}
+		function describeHit(meta) {
+			const rows = buildTooltipRows(meta);
+			return `${meta.name || meta.seriesName}，${rows.map((r) => `${r.name} ${r.value}`).join("，")}`;
+		}
+		function handlePointerDown(evt) {
+			if (isEmpty.value || internalError.value) return;
+			pointers.set(evt.pointerId, {
+				x: evt.clientX,
+				y: evt.clientY
+			});
+			if (pointers.size === 2) {
+				const [a, b] = [...pointers.values()];
+				pinchDist = Math.hypot(a.x - b.x, a.y - b.y);
+				dragState = null;
+				return;
+			}
+			const p = canvasPoint(evt);
+			if (!p) return;
+			stopAutoRotate();
+			stopInertia();
+			try {
+				canvasRef.value.setPointerCapture(evt.pointerId);
+			} catch {}
+			dragState = {
+				id: evt.pointerId,
+				x: p.x,
+				y: p.y,
+				startX: p.x,
+				startY: p.y,
+				moved: false,
+				pan: !!evt.shiftKey || props.options.interaction?.pan === true,
+				vx: 0,
+				vy: 0,
+				lastTs: 0
+			};
+		}
+		function handlePointerMove(evt) {
+			if (isEmpty.value || internalError.value) return;
+			if (pointers.has(evt.pointerId)) pointers.set(evt.pointerId, {
+				x: evt.clientX,
+				y: evt.clientY
+			});
+			if (pointers.size === 2) {
+				const [a, b] = [...pointers.values()];
+				const dist = Math.hypot(a.x - b.x, a.y - b.y);
+				if (pinchDist > 0 && dist > 0 && cameraState.value) {
+					userTouchedCamera = true;
+					applyCamera(zoomBy(cameraState.value, pinchDist / dist), { emitEvent: false });
+				}
+				pinchDist = dist;
+				return;
+			}
+			const p = canvasPoint(evt);
+			if (!p) return;
+			if (dragState && dragState.id === evt.pointerId) {
+				const dx = p.x - dragState.x;
+				const dy = p.y - dragState.y;
+				if (!dragState.moved && Math.hypot(p.x - dragState.startX, p.y - dragState.startY) < DRAG_THRESHOLD) return;
+				if (dx !== 0 || dy !== 0) {
+					dragState.moved = true;
+					dragState.x = p.x;
+					dragState.y = p.y;
+					const ts = Number.isFinite(evt.timeStamp) ? evt.timeStamp : Date.now();
+					const dt = Math.max(1, ts - (dragState.lastTs || ts - 16));
+					dragState.lastTs = ts;
+					const vx = dx / dt * .75 + dragState.vx * .25;
+					const vy = dy / dt * .75 + dragState.vy * .25;
+					dragState.vx = Math.max(-1.2, Math.min(INERTIA_MAX_SPEED, vx));
+					dragState.vy = Math.max(-1.2, Math.min(INERTIA_MAX_SPEED, vy));
+					userTouchedCamera = true;
+					const viewport = lastResult.value ? lastResult.value.viewport : null;
+					applyCamera(dragState.pan && viewport ? panBy(cameraState.value, dx, dy, viewport) : orbitBy(cameraState.value, dx, dy, viewport), { emitEvent: false });
+				}
+				tooltipVisible.value = false;
+				return;
+			}
+			const result = lastResult.value;
+			if (!result) return;
+			if (hitLegend(result.legend, p.x, p.y)) {
+				canvasRef.value.style.cursor = "pointer";
+				setHover(null, null);
+				return;
+			}
+			const hit = result.pickAt(p.x, p.y);
+			canvasRef.value.style.cursor = hit ? "pointer" : "grab";
+			setHover(hit ? hit.meta.key : null, hit, p.x, p.y);
+		}
+		function handlePointerUp(evt) {
+			pointers.delete(evt.pointerId);
+			if (pointers.size < 2) pinchDist = 0;
+			const wasDrag = dragState && dragState.id === evt.pointerId;
+			const hadMoved = wasDrag && dragState.moved;
+			const vel = wasDrag ? [dragState.vx, dragState.vy] : null;
+			const panMode = wasDrag ? dragState.pan : false;
+			dragState = null;
+			if (wasDrag && hadMoved && cameraState.value) emit("camera-change", cameraPayload(cameraState.value));
+			if (wasDrag && !hadMoved) {
+				const p = canvasPoint(evt);
+				if (p) handleClickAt(p);
+			}
+			if (hadMoved && vel) {
+				inertiaVel = vel;
+				inertiaPan = panMode;
+				startInertia();
+				return;
+			}
+			ensureAutoRotate();
+		}
+		function handleClickAt(p) {
+			const result = lastResult.value;
+			if (!result) return;
+			const legendHit = hitLegend(result.legend, p.x, p.y);
+			if (legendHit) {
+				toggleSeries(legendHit.name);
+				emit("legend-click", legendHit.name, hiddenSeries.value.has(legendHit.name));
+				render();
+				return;
+			}
+			const hit = result.pickAt(p.x, p.y);
+			if (hit) {
+				emit("click", {
+					...hit.meta,
+					x: p.x,
+					y: p.y
+				});
+				hoverKey.value = hit.meta.key;
+				render();
+			}
+		}
+		function handleDblClick(evt) {
+			if ((props.options.interaction && typeof props.options.interaction === "object" ? props.options.interaction : {}).resetOnDblClick === false) return;
+			evt.preventDefault();
+			resetCamera();
+		}
+		function handlePointerLeave() {
+			pointers.clear();
+			pinchDist = 0;
+			dragState = null;
+			setHover(null, null);
+			tooltipVisible.value = false;
+			ensureAutoRotate();
+		}
+		function handleWheel(evt) {
+			if ((props.options.interaction && typeof props.options.interaction === "object" ? props.options.interaction : {}).zoom === false) return;
+			evt.preventDefault();
+			if (!cameraState.value) return;
+			stopInertia();
+			userTouchedCamera = true;
+			applyCamera(zoomBy(cameraState.value, wheelZoomFactor(evt.deltaY)), { emitEvent: false });
+		}
+		function handleKeydown(evt) {
+			if (isEmpty.value || internalError.value) return;
+			const cam = cameraState.value;
+			if (!cam) return;
+			stopInertia();
+			const step = 8;
+			let handled = true;
+			switch (evt.key) {
+				case "ArrowLeft":
+					userTouchedCamera = true;
+					applyCamera({
+						...cam,
+						yaw: cam.yaw - step
+					});
+					break;
+				case "ArrowRight":
+					userTouchedCamera = true;
+					applyCamera({
+						...cam,
+						yaw: cam.yaw + step
+					});
+					break;
+				case "ArrowUp":
+					userTouchedCamera = true;
+					applyCamera({
+						...cam,
+						pitch: cam.pitch + step * .7
+					});
+					break;
+				case "ArrowDown":
+					userTouchedCamera = true;
+					applyCamera({
+						...cam,
+						pitch: cam.pitch - step * .7
+					});
+					break;
+				case "+":
+				case "=":
+					userTouchedCamera = true;
+					applyCamera(zoomBy(cam, .88));
+					break;
+				case "-":
+				case "_":
+					userTouchedCamera = true;
+					applyCamera(zoomBy(cam, 1.14));
+					break;
+				case "Home":
+					resetCamera();
+					break;
+				case "Escape":
+					setHover(null, null);
+					tooltipVisible.value = false;
+					break;
+				case "Enter":
+				case " ": {
+					const hit = hoverKey.value && lastResult.value ? lastResult.value.projected.items.find((i) => i.meta && i.meta.key === hoverKey.value) : null;
+					if (hit) emit("click", { ...hit.meta });
+					break;
+				}
+				default: handled = false;
+			}
+			if (handled) evt.preventDefault();
+		}
+		function handleFocusOut() {
+			setHover(null, null);
+			tooltipVisible.value = false;
+		}
+		let resizeObserver = null;
+		let themeObserver = null;
+		function handleThemeChange() {
+			render();
+		}
+		function setupWatchers() {
+			if (props.responsive && typeof ResizeObserver !== "undefined" && containerRef.value) {
+				resizeObserver = new ResizeObserver(() => scheduleRender(16));
+				resizeObserver.observe(containerRef.value);
+			}
+			if (typeof MutationObserver !== "undefined" && document.documentElement) {
+				let lastDark = document.documentElement.classList.contains("dark");
+				themeObserver = new MutationObserver(() => {
+					const nowDark = document.documentElement.classList.contains("dark");
+					if (nowDark !== lastDark) {
+						lastDark = nowDark;
+						handleThemeChange();
+					}
+				});
+				themeObserver.observe(document.documentElement, {
+					attributes: true,
+					attributeFilter: ["class"]
+				});
+			}
+			document.addEventListener("ev-theme-change", handleThemeChange);
+		}
+		watch(canvasRef, (el, prev) => {
+			if (prev) prev.removeEventListener("wheel", handleWheel);
+			if (el) el.addEventListener("wheel", handleWheel, { passive: false });
+		}, { flush: "post" });
+		function teardownWatchers() {
+			if (resizeObserver) {
+				resizeObserver.disconnect();
+				resizeObserver = null;
+			}
+			if (themeObserver) {
+				themeObserver.disconnect();
+				themeObserver = null;
+			}
+			document.removeEventListener("ev-theme-change", handleThemeChange);
+			const wheelTarget = canvasRef.value;
+			if (wheelTarget) wheelTarget.removeEventListener("wheel", handleWheel);
+		}
+		let validatedOptionsRef = null;
+		function runValidation() {
+			if (validatedOptionsRef === props.options) return;
+			validatedOptionsRef = props.options;
+			const { ok, warnings } = validateOptions3d(props.options);
+			if (ok || typeof console === "undefined") return;
+			const seen = /* @__PURE__ */ new Set();
+			for (const w of warnings) {
+				const sig = `${w.path}:${w.message}`;
+				if (seen.has(sig) || seen.size >= 8) break;
+				seen.add(sig);
+				console.warn(`[EvChart3d] ${w.path}: ${w.message}`);
+			}
+		}
+		onMounted(() => {
+			runValidation();
+			cameraState.value = currentCamera();
+			setupWatchers();
+			nextTick(() => {
+				render();
+				startEnterAnimation();
+			});
+		});
+		onBeforeUnmount(destroy);
+		watch(() => props.options, () => {
+			runValidation();
+			internalError.value = "";
+			cameraState.value = currentCamera();
+			if (cameraState.value.autoRotate) ensureAutoRotate();
+			userTouchedCamera = false;
+			hoverKey.value = null;
+			emit("data-update", {
+				from: "options",
+				to: "options"
+			});
+			if (startTweenIfNeeded()) return;
+			scheduleRender(16);
+			startEnterAnimation();
+		}, { deep: true });
+		watch(() => props.options.camera, () => {
+			cameraState.value = currentCamera();
+			if (cameraState.value.autoRotate) ensureAutoRotate();
+			else stopAutoRotate();
+			render();
+		}, { deep: true });
+		watch(() => [props.width, props.height], () => {
+			nextTick(() => scheduleRender(0));
+		});
+		function toggleSeries(name) {
+			const next = new Set(hiddenSeries.value);
+			if (next.has(name)) next.delete(name);
+			else next.add(name);
+			hiddenSeries.value = next;
+			render();
+		}
+		function destroy() {
+			stopAutoRotate();
+			stopInertia();
+			stopTween();
+			if (animRafId) {
+				cancelAnimationFrame(animRafId);
+				animRafId = 0;
+			}
+			animState = null;
+			if (renderTimer) {
+				clearTimeout(renderTimer);
+				renderTimer = null;
+			}
+			teardownWatchers();
+			lastResult.value = null;
+		}
+		function exportSVG(options = {}) {
+			const canvas = document.createElement("canvas");
+			const size = sizeCanvas();
+			const w = size ? size.cssW : 600;
+			const h = size ? size.cssH : 400;
+			canvas.width = w;
+			canvas.height = h;
+			render3d(canvas, {
+				options: props.options,
+				dpr: 1,
+				progress: 1,
+				camera: cameraState.value || currentCamera(),
+				hiddenSeries: hiddenSeries.value,
+				hoverKey: null,
+				theme: currentTheme(),
+				autoFit: !userTouchedCamera,
+				ctx: options.ctx
+			});
+			if (options.ctx && typeof options.toSvg === "function") return options.toSvg(w, h, options.backgroundColor || "#ffffff");
+			return null;
+		}
+		__expose({
+			refresh: () => render(),
+			update(newOptions) {
+				if (newOptions && typeof newOptions === "object") {
+					for (const key of Object.keys(props.options)) delete props.options[key];
+					Object.assign(props.options, newOptions);
+				}
+				internalError.value = "";
+				cameraState.value = currentCamera();
+				emit("data-update", {
+					from: "update",
+					to: "options"
+				});
+				scheduleRender(0);
+				startEnterAnimation();
+			},
+			toDataURL(type = "image/png", quality = 1) {
+				const canvas = canvasRef.value;
+				if (!canvas) return null;
+				try {
+					return canvas.toDataURL(type, quality);
+				} catch {
+					return null;
+				}
+			},
+			destroy,
+			getCanvas: () => canvasRef.value,
+			resize: () => {
+				render();
+			},
+			getCamera: () => cameraState.value ? cameraPayload(cameraState.value) : null,
+			setCamera(next) {
+				stopInertia();
+				userTouchedCamera = true;
+				applyCamera(resolveCamera({
+					...currentCamera(),
+					...next || {}
+				}));
+			},
+			resetCamera,
+			toggleSeries,
+			getHiddenSeries: () => new Set(hiddenSeries.value),
+			getProjected: () => lastResult.value,
+			exportSVG
+		});
+		const instance = getCurrentInstance();
+		if (instance) instance.appContext.config.globalProperties.$evChart3dVersion = "0.1.0";
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "containerRef",
+				ref: containerRef,
+				class: "ev-chart3d",
+				style: normalizeStyle(containerStyle.value),
+				role: "img",
+				tabindex: isEmpty.value || internalError.value ? -1 : 0,
+				"aria-label": props.options.ariaLabel || ariaLabelText.value,
+				onKeydown: handleKeydown,
+				onFocusout: handleFocusOut
+			}, [
+				!isEmpty.value && !internalError.value ? (openBlock(), createElementBlock("canvas", {
+					key: 0,
+					ref_key: "canvasRef",
+					ref: canvasRef,
+					class: "ev-chart3d__canvas",
+					onPointerdown: handlePointerDown,
+					onPointermove: handlePointerMove,
+					onPointerup: handlePointerUp,
+					onPointercancel: handlePointerUp,
+					onDblclick: handleDblClick,
+					onPointerleave: handlePointerLeave
+				}, null, 544)) : createCommentVNode("", true),
+				!isEmpty.value && !props.options.loading && !internalError.value && _ctx.$slots.overlay ? (openBlock(), createElementBlock("div", _hoisted_2, [renderSlot(_ctx.$slots, "overlay", {
+					plotArea: overlayInfo.viewport,
+					camera: overlayInfo.camera,
+					options: props.options
+				}, void 0, true)])) : createCommentVNode("", true),
+				createVNode(Transition, { name: "ev-chart3d-fade" }, {
+					default: withCtx(() => [isEmpty.value && !props.options.loading && !internalError.value ? (openBlock(), createElementBlock("div", _hoisted_3, [_cache[0] || (_cache[0] = createElementVNode("div", { class: "ev-chart3d__empty-icon-wrap" }, [createElementVNode("svg", {
+						class: "ev-chart3d__empty-img",
+						viewBox: "0 0 48 48",
+						fill: "none",
+						"aria-hidden": "true"
+					}, [createElementVNode("path", {
+						d: "M8 34 24 12l16 22",
+						stroke: "currentColor",
+						"stroke-width": "2.5",
+						"stroke-linecap": "round",
+						"stroke-linejoin": "round"
+					}), createElementVNode("path", {
+						d: "M8 34h32",
+						stroke: "currentColor",
+						"stroke-width": "2.5",
+						"stroke-linecap": "round"
+					})])], -1)), createElementVNode("span", _hoisted_4, toDisplayString(emptyText.value), 1)])) : createCommentVNode("", true)]),
+					_: 1
+				}),
+				createVNode(Transition, { name: "ev-chart3d-fade" }, {
+					default: withCtx(() => [props.options.loading && !internalError.value ? (openBlock(), createElementBlock("div", _hoisted_5, [createElementVNode("div", _hoisted_6, [(openBlock(), createElementBlock(Fragment, null, renderList(6, (i) => {
+						return createElementVNode("div", {
+							key: i,
+							class: "ev-chart3d__loading-bar",
+							style: normalizeStyle({ animationDelay: `${i * 80}ms` })
+						}, null, 4);
+					}), 64))])])) : createCommentVNode("", true)]),
+					_: 1
+				}),
+				createVNode(Transition, { name: "ev-chart3d-fade" }, {
+					default: withCtx(() => [internalError.value ? (openBlock(), createElementBlock("div", _hoisted_7, [_cache[1] || (_cache[1] = createElementVNode("span", { class: "ev-chart3d__error-icon" }, [createElementVNode("svg", {
+						viewBox: "0 0 24 24",
+						width: "1em",
+						height: "1em",
+						"aria-hidden": "true",
+						fill: "none",
+						stroke: "currentColor",
+						"stroke-width": "2",
+						"stroke-linecap": "round",
+						"stroke-linejoin": "round"
+					}, [
+						createElementVNode("circle", {
+							cx: "12",
+							cy: "12",
+							r: "9"
+						}),
+						createElementVNode("line", {
+							x1: "12",
+							y1: "7.5",
+							x2: "12",
+							y2: "13"
+						}),
+						createElementVNode("line", {
+							x1: "12",
+							y1: "16.5",
+							x2: "12",
+							y2: "16.51"
+						})
+					])], -1)), createElementVNode("span", _hoisted_8, toDisplayString(internalError.value), 1)])) : createCommentVNode("", true)]),
+					_: 1
+				}),
+				createVNode(Transition, { name: "ev-chart3d-tooltip" }, {
+					default: withCtx(() => [tooltipVisible.value && tooltipContent.value ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						ref_key: "tooltipRef",
+						ref: tooltipRef,
+						class: normalizeClass(["ev-chart3d__tooltip", `ev-chart3d__tooltip--${tooltipPlacement.value}`]),
+						style: normalizeStyle(tooltipStyle.value),
+						role: "tooltip",
+						innerHTML: tooltipContent.value
+					}, null, 14, _hoisted_9)) : createCommentVNode("", true)]),
+					_: 1
+				}),
+				createElementVNode("div", _hoisted_10, toDisplayString(ariaLiveText.value), 1)
+			], 44, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-36ccea38"]]);
+//#endregion
+//#region src/3d/useChart3d.js
+/**
+* useChart3d — 命令式使用三维图表的组合式 API
+* 模板里仍用 <EvChart3d ref="chartRef">，本 composable 只是把常用实例方法
+* 收拢成解构友好的形式，并提供相机快捷操作。
+*/
+function useChart3d() {
+	const containerRef = ref(null);
+	const chartRef = shallowRef(null);
+	const disposed = ref(false);
+	const invoke = (method, ...args) => {
+		const inst = chartRef.value;
+		if (!inst || typeof inst[method] !== "function") return void 0;
+		return inst[method](...args);
+	};
+	onBeforeUnmount(() => {
+		disposed.value = true;
+		invoke("destroy");
+	});
+	return {
+		containerRef,
+		chartRef,
+		/** 相机读取/写入（自动触发重绘并派发 camera-change） */
+		getCamera: () => invoke("getCamera"),
+		setCamera: (next) => invoke("setCamera", next),
+		resetCamera: () => invoke("resetCamera"),
+		/** 相机快捷操作：环绕（度）与缩放（倍率） */
+		orbit: (dYaw, dPitch) => {
+			const cam = invoke("getCamera");
+			if (!cam) return null;
+			return invoke("setCamera", {
+				yaw: cam.yaw + (dYaw || 0),
+				pitch: cam.pitch + (dPitch || 0)
+			});
+		},
+		zoom: (factor) => {
+			const cam = invoke("getCamera");
+			if (!cam) return null;
+			return invoke("setCamera", { distance: cam.distance * (factor || 1) });
+		},
+		toggleSeries: (name) => invoke("toggleSeries", name),
+		getHiddenSeries: () => invoke("getHiddenSeries"),
+		toDataURL: (type, quality) => invoke("toDataURL", type, quality),
+		exportSVG: (options) => invoke("exportSVG", options),
+		refresh: () => invoke("refresh"),
+		resize: () => invoke("resize"),
+		getProjected: () => invoke("getProjected"),
+		isDisposed: () => disposed.value
+	};
+}
+//#endregion
+//#region src/3d/renderer/svgRecorder.js
+/**
+* SVG 导出录制器 — 用一个实现 Canvas 2D 接口的代理替换真 ctx，
+* 把绘制调用重放为 SVG 元素，实现三维图的矢量导出。
+*
+* 与 evoke-charts 的 svgRecorder 同思路、同 API 形状（{ ctx, toSvg }），
+* 但按三维管线的实际用量裁剪：无裁剪、无位图；线性渐变（面内渐变）转 <linearGradient>。
+* 面是凸多边形 → 路径直出；文字按当前 CTM 反推锚点坐标。
+*
+* 注意：禁止使用 RegExp.exec（安全扫描误报），统一用 match。
+*/
+function applyMatrix(m, x, y) {
+	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function multiply(m1, m2) {
+	return [
+		m1[0] * m2[0] + m1[2] * m2[1],
+		m1[1] * m2[0] + m1[3] * m2[1],
+		m1[0] * m2[2] + m1[2] * m2[3],
+		m1[1] * m2[2] + m1[3] * m2[3],
+		m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+		m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+	];
+}
+function escapeXml(s) {
+	return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** 解析 canvas font 字符串 */
+function parseFont(font) {
+	const s = typeof font === "string" ? font : "12px sans-serif";
+	const sizeMatch = s.match(/(\d+(?:\.\d+)?)px/);
+	const size = sizeMatch ? parseFloat(sizeMatch[1]) : 12;
+	const weight = /bold/.test(s) ? "bold" : /[67]00/.test(s) ? "600" : "normal";
+	const familyMatch = s.match(/px\s+(.*)$/);
+	return {
+		size,
+		weight,
+		family: (familyMatch ? familyMatch[1] : "sans-serif").replace(/["']/g, "")
+	};
+}
+/** canvas 对齐值 → SVG text-anchor */
+var ANCHOR = {
+	left: "start",
+	start: "start",
+	center: "middle",
+	right: "end",
+	end: "end"
+};
+/** canvas 基线 → SVG dominant-baseline */
+var BASELINE = {
+	alphabetic: "alphabetic",
+	middle: "central",
+	middle_alias: "central",
+	top: "text-before-edge",
+	hanging: "text-before-edge",
+	bottom: "text-after-edge",
+	ideographic: "text-after-edge"
+};
+function colorToSvg(value) {
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object" && typeof value.toString === "function") return value.toString();
+	return "#000000";
+}
+/**
+* @param {CanvasRenderingContext2D} real 真实 ctx，仅用于 measureText 等测量能力
+* @returns {{ctx: object, toSvg: (width:number, height:number, backgroundColor?:string) => string}}
+*/
+function createSvgRecorder(real) {
+	const elements = [];
+	const gradients = [];
+	let matrix = [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	const matrixStack = [];
+	const styleStack = [];
+	let path = [];
+	let hasPath = false;
+	const style = {
+		fillStyle: "#000000",
+		strokeStyle: "#000000",
+		lineWidth: 1,
+		globalAlpha: 1,
+		font: "12px sans-serif",
+		textAlign: "start",
+		textBaseline: "alphabetic",
+		lineDash: [],
+		lineCap: "butt",
+		lineJoin: "miter"
+	};
+	/** 填充样式 → SVG 值：渐变登记为 <linearGradient> 并引用 */
+	function resolveFill() {
+		if (typeof style.fillStyle === "string") return style.fillStyle;
+		const g = style.fillStyle;
+		if (!g || !g.__gradient) return colorToSvg(g);
+		gradients.push(g);
+		return `url(#evg${gradients.length - 1})`;
+	}
+	function pushPath(fill, stroke) {
+		if (!hasPath || !path.length) return;
+		let d = "";
+		for (const cmd of path) {
+			const pts = [];
+			for (let i = 0; i < cmd.pts.length; i += 2) {
+				const [x, y] = applyMatrix(matrix, cmd.pts[i], cmd.pts[i + 1]);
+				pts.push(x.toFixed(2), y.toFixed(2));
+			}
+			if (cmd.op === "M") d += `M${pts[0]},${pts[1]}`;
+			else if (cmd.op === "L") d += `L${pts[0]},${pts[1]}`;
+			else if (cmd.op === "Q") d += `Q${pts.join(",")}`;
+			else if (cmd.op === "C") d += `C${pts.join(",")}`;
+			else if (cmd.op === "A") {
+				const cx = cmd.pts[0];
+				const cy = cmd.pts[1];
+				const r = cmd.pts[2];
+				const a0 = cmd.pts[3];
+				const a1 = cmd.pts[4];
+				const [tsx, tsy] = applyMatrix(matrix, cx + Math.cos(a0) * r, cy + Math.sin(a0) * r);
+				const [tex, tey] = applyMatrix(matrix, cx + Math.cos(a1) * r, cy + Math.sin(a1) * r);
+				const scale = (Math.hypot(matrix[0], matrix[1]) + Math.hypot(matrix[2], matrix[3])) / 2;
+				d += `M${tsx.toFixed(2)},${tsy.toFixed(2)}A${(r * scale).toFixed(2)},${(r * scale).toFixed(2)} 0 0 ${cmd.pts[5] ? 0 : 1} ${tex.toFixed(2)},${tey.toFixed(2)}`;
+			}
+			if (cmd.closed) d += "Z";
+		}
+		const attrs = {
+			d,
+			fill: fill ? resolveFill() : "none",
+			"fill-opacity": fill && style.globalAlpha < 1 ? style.globalAlpha.toFixed(3) : void 0
+		};
+		if (stroke) {
+			attrs.stroke = colorToSvg(style.strokeStyle);
+			attrs["stroke-width"] = style.lineWidth;
+			attrs["stroke-opacity"] = style.globalAlpha < 1 ? style.globalAlpha.toFixed(3) : void 0;
+			attrs["stroke-linecap"] = style.lineCap;
+			attrs["stroke-linejoin"] = style.lineJoin;
+			if (style.lineDash && style.lineDash.length) attrs["stroke-dasharray"] = style.lineDash.join(" ");
+		}
+		elements.push({
+			tag: "path",
+			attrs
+		});
+	}
+	const proxy = {
+		save() {
+			matrixStack.push(matrix.slice());
+			styleStack.push({
+				...style,
+				lineDash: style.lineDash.slice()
+			});
+		},
+		restore() {
+			const m = matrixStack.pop();
+			const s = styleStack.pop();
+			if (m) matrix = m;
+			if (s) Object.assign(style, s);
+		},
+		setTransform(a, b, c, d, e, f) {
+			matrix = [
+				a,
+				b,
+				c,
+				d,
+				e,
+				f
+			];
+		},
+		transform(a, b, c, d, e, f) {
+			matrix = multiply(matrix, [
+				a,
+				b,
+				c,
+				d,
+				e,
+				f
+			]);
+		},
+		translate(x, y) {
+			matrix = multiply(matrix, [
+				1,
+				0,
+				0,
+				1,
+				x,
+				y
+			]);
+		},
+		scale(x, y) {
+			matrix = multiply(matrix, [
+				x,
+				0,
+				0,
+				y,
+				0,
+				0
+			]);
+		},
+		rotate(rad) {
+			const c = Math.cos(rad);
+			const s = Math.sin(rad);
+			matrix = multiply(matrix, [
+				c,
+				s,
+				-s,
+				c,
+				0,
+				0
+			]);
+		},
+		beginPath() {
+			path = [];
+			hasPath = true;
+		},
+		closePath() {
+			if (path.length) path[path.length - 1].closed = true;
+		},
+		moveTo(x, y) {
+			path.push({
+				op: "M",
+				pts: [x, y]
+			});
+		},
+		lineTo(x, y) {
+			path.push({
+				op: "L",
+				pts: [x, y]
+			});
+		},
+		quadraticCurveTo(cx, cy, x, y) {
+			path.push({
+				op: "Q",
+				pts: [
+					cx,
+					cy,
+					x,
+					y
+				]
+			});
+		},
+		bezierCurveTo(c1x, c1y, c2x, c2y, x, y) {
+			path.push({
+				op: "C",
+				pts: [
+					c1x,
+					c1y,
+					c2x,
+					c2y,
+					x,
+					y
+				]
+			});
+		},
+		arc(x, y, r, a0, a1, ccw) {
+			path.push({
+				op: "A",
+				pts: [
+					x,
+					y,
+					r,
+					a0,
+					a1,
+					!!ccw
+				]
+			});
+		},
+		rect(x, y, w, h) {
+			path.push({
+				op: "M",
+				pts: [x, y]
+			});
+			path.push({
+				op: "L",
+				pts: [x + w, y]
+			});
+			path.push({
+				op: "L",
+				pts: [x + w, y + h]
+			});
+			path.push({
+				op: "L",
+				pts: [x, y + h]
+			});
+			path[path.length - 1].closed = true;
+		},
+		fill() {
+			pushPath(true, false);
+		},
+		stroke() {
+			pushPath(false, true);
+		},
+		fillRect(x, y, w, h) {
+			proxy.beginPath();
+			proxy.rect(x, y, w, h);
+			pushPath(true, false);
+			path = [];
+		},
+		strokeRect(x, y, w, h) {
+			proxy.beginPath();
+			proxy.rect(x, y, w, h);
+			pushPath(false, true);
+			path = [];
+		},
+		clearRect() {},
+		clip() {},
+		fillText(text, x, y) {
+			const [tx, ty] = applyMatrix(matrix, x, y);
+			const f = parseFont(style.font);
+			const baselineOffset = style.textBaseline === "alphabetic" ? 0 : 0;
+			elements.push({
+				tag: "text",
+				attrs: {
+					x: (tx + baselineOffset).toFixed(2),
+					y: ty.toFixed(2),
+					fill: colorToSvg(style.fillStyle),
+					"font-size": f.size,
+					"font-family": f.family,
+					"font-weight": f.weight,
+					"text-anchor": ANCHOR[style.textAlign] || "start",
+					"dominant-baseline": BASELINE[style.textBaseline] || "alphabetic",
+					...style.globalAlpha < 1 ? { "fill-opacity": style.globalAlpha.toFixed(3) } : {}
+				},
+				text: String(text)
+			});
+		},
+		strokeText() {},
+		measureText(text) {
+			if (real && typeof real.measureText === "function") return real.measureText(text);
+			return { width: String(text).length * 7 };
+		},
+		createLinearGradient(x0, y0, x1, y1) {
+			const [tx0, ty0] = applyMatrix(matrix, x0, y0);
+			const [tx1, ty1] = applyMatrix(matrix, x1, y1);
+			return {
+				__gradient: true,
+				x0: tx0,
+				y0: ty0,
+				x1: tx1,
+				y1: ty1,
+				stops: [],
+				addColorStop(offset, color) {
+					this.stops.push({
+						offset,
+						color
+					});
+				}
+			};
+		},
+		createRadialGradient() {
+			return {
+				__gradient: false,
+				addColorStop() {}
+			};
+		},
+		setLineDash(dash) {
+			style.lineDash = Array.isArray(dash) ? dash.slice() : [];
+		},
+		getLineDash() {
+			return style.lineDash.slice();
+		},
+		drawImage() {},
+		isPointInPath() {
+			return false;
+		}
+	};
+	const ctx = new Proxy(proxy, {
+		get(target, prop) {
+			if (prop in style) return style[prop];
+			if (prop in target) return target[prop];
+		},
+		set(target, prop, value) {
+			if (prop in style) {
+				style[prop] = value;
+				return true;
+			}
+			target[prop] = value;
+			return true;
+		}
+	});
+	/** 渐变定义：坐标已随 CTM 落到最终画布空间，用 userSpaceOnUse 直出 */
+	function gradientDefs() {
+		return gradients.map((g, i) => {
+			const stops = g.stops.map((s) => `<stop offset="${(s.offset * 100).toFixed(1)}%" stop-color="${escapeXml(String(s.color))}"/>`).join("");
+			return `<linearGradient id="evg${i}" gradientUnits="userSpaceOnUse" x1="${g.x0.toFixed(1)}" y1="${g.y0.toFixed(1)}" x2="${g.x1.toFixed(1)}" y2="${g.y1.toFixed(1)}">${stops}</linearGradient>`;
+		}).join("");
+	}
+	function toSvg(width, height, backgroundColor = "#ffffff") {
+		const body = elements.map((el) => {
+			const attrs = Object.entries(el.attrs).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}="${escapeXml(v)}"`).join(" ");
+			if (el.tag === "text") return `<text ${attrs}>${escapeXml(el.text)}</text>`;
+			return `<${el.tag} ${attrs}/>`;
+		}).join("\n");
+		return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${gradients.length ? `<defs>${gradientDefs()}</defs>` : ""}<rect width="${width}" height="${height}" fill="${colorToSvg(backgroundColor)}"/>${body}</svg>`;
+	}
+	return {
+		ctx,
+		toSvg
+	};
+}
+//#endregion
+//#region src/3d/index.js
+/**
+* Evoke Charts · 三维篇章（@wil-works/evoke-charts/3d）
+*
+* 与二维主入口（./index.js）平行的独立篇章：自绘透视投影管线
+* （向量/矩阵数学 → 轨道相机 → 场景图元 → 画家算法深度排序 → Canvas 2D），
+* 不依赖 WebGL 封装库；色系 / 令牌 / 换肤事件与二维同源。
+* 独立子入口保证只用二维的消费方不背三维的包体。
+*/
+var components = { EvChart3d: chart3d_default };
+function install(app, _options = {}) {
+	for (const [name, component] of Object.entries(components)) app.component(name, component);
+}
+var Charts3d = { install };
+var _3d_default = { install };
+//#endregion
+export { CHART3D_PALETTES, CHART3D_PALETTE_IDS, CHART3D_RAMPS, CHART3D_TYPES, CHART_COLORS, Charts3d, DEFAULT_CAMERA, chart3d_default as EvChart3d, applySeriesPalette, chart3dOptionsSchema, clearSeriesPalette, components, createSvgRecorder, _3d_default as default, easings, getTheme, install, pickScene, projectScene, render3d, resolveCamera, resolveChartPalette, resolveChartRamp, useChart3d, validateOptions3d };