@pioneer_zmc/dsh-workbench 0.2.1

package/web/assets/rooms/templates.json

@@ -0,0 +1,50 @@
+{
+  "schemaVersion": 1,
+  "note": "两套底座共享同一份空间布局，仅风格身份不同。空间数据来自 E2a 任务单固定值，并须与两套底座 meta 比对。",
+  "templates": [
+    {
+      "schemaVersion": 1,
+      "templateId": "room-ceramic-01",
+      "styleId": "ceramic",
+      "name": "写实底座·项目介绍室",
+      "interiorBounds": { "minX": -4, "maxX": 4, "minY": 0, "maxY": 3.4, "minZ": -3, "maxZ": 3 },
+      "zones": [
+        { "zoneId": "floor-main", "name": "室内地面陈设区", "kind": "floor", "bounds": { "minX": -3.7, "maxX": 3.7, "minY": 0, "maxY": 3.0, "minZ": -2.7, "maxZ": 2.7 } }
+      ],
+      "entry": {
+        "wall": "north",
+        "door": { "centerX": 2.25, "centerZ": -3, "width": 1.4, "height": 2.55, "opens": "outward" },
+        "inward": "+Z",
+        "spawn": { "x": 2.25, "z": -2.35 }
+      },
+      "reservedVolumes": [
+        { "id": "entry-clear", "name": "入口禁放区", "purpose": "entry", "bounds": { "minX": 1.55, "maxX": 2.95, "minY": 0, "maxY": 2.1, "minZ": -3, "maxZ": -1.4 } },
+        { "id": "aisle-main", "name": "主通路", "purpose": "corridor", "bounds": { "minX": 1.65, "maxX": 2.85, "minY": 0, "maxY": 2.1, "minZ": -2, "maxZ": 2.4 } },
+        { "id": "aisle-display", "name": "展示通路", "purpose": "corridor", "bounds": { "minX": -3.6, "maxX": 2.85, "minY": 0, "maxY": 2.1, "minZ": 1, "maxZ": 2.05 } }
+      ],
+      "walkProfile": { "radius": 0.26, "eyeClearance": 1.9 }
+    },
+    {
+      "schemaVersion": 1,
+      "templateId": "room-fairy-01",
+      "styleId": "fairy",
+      "name": "童话底座·项目介绍室",
+      "interiorBounds": { "minX": -4, "maxX": 4, "minY": 0, "maxY": 3.4, "minZ": -3, "maxZ": 3 },
+      "zones": [
+        { "zoneId": "floor-main", "name": "室内地面陈设区", "kind": "floor", "bounds": { "minX": -3.7, "maxX": 3.7, "minY": 0, "maxY": 3.0, "minZ": -2.7, "maxZ": 2.7 } }
+      ],
+      "entry": {
+        "wall": "north",
+        "door": { "centerX": 2.25, "centerZ": -3, "width": 1.4, "height": 2.55, "opens": "outward" },
+        "inward": "+Z",
+        "spawn": { "x": 2.25, "z": -2.35 }
+      },
+      "reservedVolumes": [
+        { "id": "entry-clear", "name": "入口禁放区", "purpose": "entry", "bounds": { "minX": 1.55, "maxX": 2.95, "minY": 0, "maxY": 2.1, "minZ": -3, "maxZ": -1.4 } },
+        { "id": "aisle-main", "name": "主通路", "purpose": "corridor", "bounds": { "minX": 1.65, "maxX": 2.85, "minY": 0, "maxY": 2.1, "minZ": -2, "maxZ": 2.4 } },
+        { "id": "aisle-display", "name": "展示通路", "purpose": "corridor", "bounds": { "minX": -3.6, "maxX": 2.85, "minY": 0, "maxY": 2.1, "minZ": 1, "maxZ": 2.05 } }
+      ],
+      "walkProfile": { "radius": 0.26, "eyeClearance": 1.9 }
+    }
+  ]
+}

package/web/assets/rooms/walk-frame.js

@@ -0,0 +1,64 @@
+// 独立房间的行走帧推进（P1c-2c-2）：把已验收的行走会话（walk-session.js）、
+// 原版输入器（building-walk.js 的 createWalkInput）与一台 Three 相机接成"每帧一步"。
+// 只做状态推进与相机同步，不建动画循环、不建第二套会话、不碰 DOM——
+// 渲染循环由 room-scene.js 的 renderer.setAnimationLoop 驱动，本模块只提供 frame()。
+// 相机由调用方传入并直接读写其 position／rotation（YXZ 欧拉），本模块不导入 Three.js，
+// Node 测试可直连。参数与旧建筑页手感一致：眼高 1.65、视场 66、步行 2.6 m/s、
+// Shift 4.6 m/s、俯仰限 ±0.44π；帧间隔超过 0.05 秒按 0.05 截断，时钟重置后首帧 dt=0
+// （页面隐藏／往返缓存／切模式回来，不把离开的时间算成位移）。
+
+export const EYE_HEIGHT = 1.65
+export const WALK_FOV = 66
+export const PITCH_LIMIT = Math.PI * 0.44
+export const WALK_SPEED = 2.6
+export const WALK_RUN_SPEED = 4.6
+export const MAX_FRAME_DT = 0.05
+
+/** 从 from 看向 to 的 yaw（Three 相机面向局部 -Z）：门外出生看向门中心应得 ±π。 */
+export function lookYawToward(from, to) {
+  return Math.atan2(-(to.x - from.x), -(to.z - from.z))
+}
+
+/**
+ * 建一个行走帧推进器。session 是人物位置与门开合的唯一来源；input 只需提供
+ * 原版输入器的 axis()／takeLook() 两个读法（测试可用同形小桩）。
+ * 每帧：先应用环顾增量，再用新 yaw 算本帧位移交 session.move，最后把相机
+ * 同步到脚底＋眼高。位移公式与旧建筑页一致，斜向输入按长度归一。
+ */
+export function createWalkFrame({ session, input, camera, yaw = 0, pitch = 0 } = {}) {
+  let lastTime = null
+
+  function frame(timeMs) {
+    const seconds = Number(timeMs) / 1000
+    const dt = lastTime === null || !Number.isFinite(seconds)
+      ? 0
+      : Math.min(Math.max(seconds - lastTime, 0), MAX_FRAME_DT)
+    if (Number.isFinite(seconds)) lastTime = seconds
+
+    const lookDelta = input.takeLook()
+    yaw += lookDelta.yaw
+    pitch = Math.max(-PITCH_LIMIT, Math.min(PITCH_LIMIT, pitch + lookDelta.pitch))
+
+    const { forward, right, fast } = input.axis()
+    const length = Math.hypot(forward, right)
+    if (length > 0) {
+      const step = dt * (fast ? WALK_RUN_SPEED : WALK_SPEED)
+      session.move(
+        (-Math.sin(yaw) * forward + Math.cos(yaw) * right) / length * step,
+        (-Math.cos(yaw) * forward - Math.sin(yaw) * right) / length * step,
+      )
+    }
+
+    const state = session.getState()
+    camera.position.set(state.position.x, state.position.y + EYE_HEIGHT, state.position.z)
+    camera.rotation.set(pitch, yaw, 0, 'YXZ')
+  }
+
+  return {
+    frame,
+    /** 丢掉计时基线：下一帧 dt=0。页面隐藏／往返缓存恢复／切模式后调用。 */
+    resetClock() { lastTime = null },
+    /** 当前保存的行走视线（总览期间不被覆盖，恢复行走继续用）。 */
+    getLook() { return { yaw, pitch } },
+  }
+}

package/web/assets/rooms/walk-session.js

@@ -0,0 +1,138 @@
+// 独立房间 · 行走会话（P1c-2c-1）：把真实门句柄、室外导航快照与人物脚底位置交给
+// 一个小模块管理；页面按钮与渲染循环只与会话对话，不各自直改底座门。会话只做状态
+// 与事务：不导入 Three.js、不访问 DOM、不建帧循环／定时器／事件监听，也不管相机
+// 朝向、键盘输入、速度或 dt（下一单场景负责把输入换算成世界位移）。
+// 导航与碰撞全部复用现有模块：buildRoomOutdoorWalkData 做数据翻译，原版
+// building-walk 的 createNavigator／entryPoint 做判定，本模块零复制、零改造；
+// 人物脚底位置来自导航入口，不把坐标再写死一份。
+// 门开合是同步事务（无 await、无动画、无中途通知，渲染循环不会看见候选的临时门
+// 姿态）：先在内存把真实门切到目标端点、取真实世界包围盒重建候选导航，用候选
+// canStand 检查人物当前站位（整体半径与躯干净高，不是点是否在盒内）；站得住才
+// 提交，站不住立即恢复门端点并继续用旧导航，人物位置全程不动。本轮门只在 0°／
+// 90° 两端点瞬时切换、不做动画；将来加开门动画须另做扫掠碰撞，不能沿用端点检查。
+
+import { buildRoomOutdoorWalkData } from './navigation.js'
+import { createNavigator, entryPoint } from '../building-walk.js'
+
+/** 门句柄检查：三个方法齐全且当前关闭；会话不擅自改变调用者已有的门姿态。 */
+function assertDoorHandle(door) {
+  if (!door || typeof door !== 'object') {
+    throw new Error('房间行走会话失败：缺少 door——会话需要真实底座返回的门句柄（setOpen／isOpen／getBounds），不接受门盒快照或 Three.js 对象。')
+  }
+  for (const method of ['setOpen', 'isOpen', 'getBounds']) {
+    if (typeof door[method] !== 'function') {
+      throw new Error(`房间行走会话失败：门句柄缺少 ${method} 方法，不是完整的真实门接口，会话无法安全地开关门。`)
+    }
+  }
+  if (door.isOpen() !== false) {
+    throw new Error('房间行走会话失败：会话只能从关闭的门开始（当前 isOpen() 为 true）。请以 { doorOpen: false } 创建底座后传入；会话不擅自改变调用者已有的门姿态。')
+  }
+}
+
+/** 用门当前真实包围盒构建候选导航（数据适配＋原版导航器）；失败由调用方恢复门。 */
+function buildNavFromDoor(template, assembly, door) {
+  const data = buildRoomOutdoorWalkData(template, assembly, { doorBounds: door.getBounds() })
+  return { data, nav: createNavigator(data.model, data.presentation) }
+}
+
+/**
+ * 建立一次行走会话。调用前提：template 与 assembly 来自成功的真实 validatePlacement，
+ * door 是以 { doorOpen: false } 创建的真实底座门句柄。返回：
+ *   getState()                    → { mode, position:{x,y,z}, doorOpen, spaceId } 新快照
+ *   setMode('walk'|'overview')    → 切模式返回新状态；总览不移动，回行走不重新出生
+ *   move(dx,dz)                   → 世界 X/Z 位移；仅 walk 模式生效，撞墙滑动由原导航决定
+ *   setDoorOpen(boolean)          → { ok, code, message, state }；人物挡目标门板时
+ *                                   code='door-blocked-by-player'，非法参数抛中文错误
+ * 没有传送、任意 setPosition 或“撞墙重生”接口；底座资源释放仍归场景所有。
+ */
+export function createRoomWalkSession({ template, assembly, door } = {}) {
+  if (!template || !assembly) {
+    throw new Error('房间行走会话失败：需要同时提供 template 与 assembly（来自成功的真实 validatePlacement），会话不重新推算家具、门盒或场地边界。')
+  }
+  assertDoorHandle(door)
+
+  let current = buildNavFromDoor(template, assembly, door)
+  const entry = entryPoint(current.data.model)
+  if (!entry || !current.nav.canStand({ x: entry.x, y: entry.y, z: entry.z })) {
+    throw new Error(`房间行走会话失败：门外出生点（${entry ? `${entry.x}, ${entry.y}, ${entry.z}` : '模型缺少 entry'}）在当前门姿态下不可站立，会话拒绝在不成立的场地上开局。`)
+  }
+  let mode = 'walk'
+  let position = { x: entry.x, y: entry.y, z: entry.z }
+
+  /** 每次新构造的快照：外部修改快照不影响会话内部状态。 */
+  function snapshot() {
+    return {
+      mode,
+      position: { x: position.x, y: position.y, z: position.z },
+      doorOpen: door.isOpen(),
+      spaceId: current.nav.locate(position)?.id ?? null,
+    }
+  }
+
+  return {
+    getState: snapshot,
+
+    setMode(nextMode) {
+      if (nextMode !== 'walk' && nextMode !== 'overview') {
+        throw new Error(`房间行走会话失败：setMode 只接受 walk／overview，收到「${String(nextMode)}」；行走与总览的切换不改变人物站位。`)
+      }
+      mode = nextMode
+      return snapshot()
+    },
+
+    move(dx, dz) {
+      if (!Number.isFinite(dx) || !Number.isFinite(dz)) {
+        throw new Error(`房间行走会话失败：move 的位移必须是有限数（收到 dx=${String(dx)}，dz=${String(dz)}）。`)
+      }
+      const distance = Math.hypot(dx, dz)
+      if (distance > 30) {
+        throw new Error(`房间行走会话失败：move 的单次位移不得超过 30 米（收到 ${distance} 米）；目录定位等跳转不归会话管。`)
+      }
+      if (mode === 'walk') {
+        const next = current.nav.move(position, dx, dz)
+        position = { x: next.x, y: next.y, z: next.z }
+      }
+      return snapshot()
+    },
+
+    setDoorOpen(open) {
+      if (typeof open !== 'boolean') {
+        throw new Error(`房间行走会话失败：setDoorOpen 只接受 boolean（收到「${String(open)}」）。`)
+      }
+      const previous = door.isOpen()
+      if (open === previous) {
+        return { ok: true, code: 'ok', message: `门已经是${open ? '打开' : '关闭'}状态，无需切换。`, state: snapshot() }
+      }
+      // 事务主体：真实门切到目标端点 → 真实包围盒重建候选导航 → 站位检查。
+      // 构造中途任何异常都先恢复门原端点、保留旧导航与人物状态，再抛中文错误，
+      // 不留下半次成功。开门与关门对称检查；总览模式同样检查保留的行走站位。
+      let candidate = null
+      try {
+        door.setOpen(open)
+        candidate = buildNavFromDoor(template, assembly, door)
+      } catch (error) {
+        let restoreFailure = null
+        try {
+          door.setOpen(previous)
+        } catch (restoreError) {
+          restoreFailure = restoreError
+        }
+        if (restoreFailure) {
+          throw new Error(`房间行走会话失败：门切到${open ? '打开' : '关闭'}端点后构造导航失败（${error.message}），且恢复门原端点也失败（${restoreFailure.message}）；人物位置与导航保持原状，请检查底座门状态。`)
+        }
+        throw new Error(`房间行走会话失败：门切到${open ? '打开' : '关闭'}端点后构造导航失败（${error.message}）；门已恢复${previous ? '打开' : '关闭'}端点，人物位置与导航保持原状。`)
+      }
+      if (candidate.nav.canStand({ x: position.x, y: position.y, z: position.z })) {
+        current = candidate
+        return { ok: true, code: 'ok', message: `门已${open ? '打开' : '关闭'}，导航与碰撞已按新的门姿态重建。`, state: snapshot() }
+      }
+      door.setOpen(previous)
+      return {
+        ok: false,
+        code: 'door-blocked-by-player',
+        message: `人物当前位置与${open ? '打开' : '关闭'}后的门板重叠，请先挪开人物再${open ? '开' : '关'}门；门与导航保持原状。`,
+        state: snapshot(),
+      }
+    },
+  }
+}

package/web/assets/save-result.js

@@ -0,0 +1,89 @@
+// 保存弹层的两条状态规则（纯逻辑：不碰 DOM、不发请求，可被 scripts/check-save.mjs 直接
+// import 断言；页面里只剩"取数—渲染—发请求"的接线）。放这里的另一个原因：页面层没有
+// 浏览器外的跑法，规则留在页面里就只能靠"源码里有没有这句话"来验，写在这里能真跑。
+//
+// ① 页面正展示的那份内容的摘要由本模块保管，只有"重新加载并展示了内容"才更新它。
+//    保存成功后原地刷新版本条**不更新**——屏幕上还是原来那一份图与说明，过期检查就必须
+//    仍按原来那一份算；否则后台在两次读取之间改了文件，页面会放行保存一份自己没展示过的内容。
+// ② 一次保存请求的结果怎么算：ok 只认"状态成功 + 正文完整"，缺一不可——状态成功但正文
+//    读不出来时结果未知，不能当成功，更不能去读一个可能为空的正文。
+
+/** 页面正展示内容的摘要（v 不是 current、或摘要取不出来时为 null）。 */
+let shown = null
+
+/** 内容真正被加载并展示时调用（main 里一次）。刷新版本条不走这里。 */
+export function rememberShown(data) {
+  shown = data && typeof data.currentFingerprint === 'string' ? data.currentFingerprint : null
+}
+
+/** 页面正展示内容的摘要（保存自查与提交时送回服务端用）。 */
+export function shownFingerprint() {
+  return shown
+}
+
+/**
+ * 弹层打开时的自查：把"这次读到的已提交内容"与"页面正展示的那一份"对一下。
+ * check 是 GET /api/snapshots 的结果；请求没回来时传 { failed: 原因 }。
+ * 返回 state：check-failed / no-repo / uncommitted / unknown / stale / ok（只有 ok 放行）。
+ */
+export function saveGate(shownPrint, check) {
+  if (check && typeof check.failed === 'string') {
+    return { state: 'check-failed', text: `没能检查这一版能不能存：${check.failed}` }
+  }
+  if (check && check.code === 'repo-not-configured') {
+    return { state: 'no-repo', text: check.error }
+  }
+  if (!check || check.ok !== true) {
+    return {
+      state: 'uncommitted',
+      text: '请先提交，再保存版本：',
+      problems: Array.isArray(check?.problems) ? check.problems : [],
+    }
+  }
+  if (typeof shownPrint !== 'string' || !shownPrint) {
+    return {
+      state: 'unknown',
+      text: '这一版的内容摘要取不出来（有文件读不开），没法确认页面是不是最新的：请刷新页面后再保存。',
+    }
+  }
+  if (check.fingerprint !== shownPrint) {
+    return {
+      state: 'stale',
+      text: '内容已更新，请刷新后确认：页面上看到的这一版，和将要保存的内容已经不是同一份了。',
+    }
+  }
+  return { state: 'ok', text: `将保存为提交 ${String(check.head).slice(0, 8)} 的快照，内容与你正在看的一致。` }
+}
+
+/**
+ * 一次保存请求的结果 → 页面该做什么。responded/ok/status/body 是这次 fetch 的实况。
+ * 返回 kind：created / already / created-unverified / rejected / unknown。
+ */
+export function saveOutcome({ responded, ok, status, body }) {
+  const snapshot = body && typeof body === 'object' ? body.snapshot : null
+  const label = snapshot && snapshot.meta && typeof snapshot.meta.name === 'string' ? snapshot.meta.name : ''
+  const reason = body && typeof body.error === 'string' ? body.error : ''
+  if (!responded) {
+    return {
+      kind: 'unknown',
+      text: '没能确认有没有保存成功：请求没有回应。请刷新页面看版本列表，确认这一版是否已经存上，再决定要不要重存。',
+    }
+  }
+  if (!ok) {
+    // 版本已经写上去了、只是没核完：这话不能说成"没能保存"（用户会以为没存上又存一遍）
+    if (body && body.code === 'save-created-unverified') {
+      return {
+        kind: 'created-unverified',
+        text: `${reason || '版本可能已经写上去了，但读回核对没做完。'} 先刷新版本条核对，不要急着重存。`,
+      }
+    }
+    return { kind: 'rejected', text: `没能保存：${reason || `服务端返回 ${status}`}` }
+  }
+  if (!label) {
+    return {
+      kind: 'unknown',
+      text: '没能确认有没有保存成功：服务端说成功了，但回来的内容不完整。请刷新页面看版本列表，确认这一版是否已经存上，再决定要不要重存。',
+    }
+  }
+  return { kind: body.alreadySaved === true ? 'already' : 'created', label }
+}

package/web/assets/showcase.js

@@ -0,0 +1,232 @@
+// 展示页：项目级业务展示，列表／星图／球阵三种格式，切换器吸顶、选择记入本地存储。
+// 星图与球阵都是自绘轻量实现（不引新依赖）：星图＝SVG 星座，球阵＝斐波那契球面＋自转投影。
+// 沿用星图小样的产品口径：位置按业务 id 稳定分配不重叠；切走即停渲染；
+// 减少动态效果偏好下先给静态布局，由用户点「开始旋转」明确启动。
+// 不用占位星/占位球：次级节点用真实流程图数据，不伪造业务。
+import { $, businessCard, el, fetchJson, pageTitle, renderEmptyWorkspaceParam, renderGuide, renderRepoLine, renderRepoState, setStatus, showError, workspaceParamEmpty, wsUrl } from './common.js'
+
+const VIEW_KEY = 'archify-showcase-view'
+const VIEWS = ['list', 'star', 'sphere']
+
+function storedView() {
+  try {
+    const value = localStorage.getItem(VIEW_KEY)
+    return VIEWS.includes(value) ? value : 'list'
+  } catch {
+    return 'list'
+  }
+}
+
+function storeView(view) {
+  try {
+    localStorage.setItem(VIEW_KEY, view)
+  } catch {
+    // 存储受限（隐私模式等）：只影响本次打开的默认格式，不报错。
+  }
+}
+
+const SVG_NS = 'http://www.w3.org/2000/svg'
+function svgEl(tag, attrs = {}) {
+  const node = document.createElementNS(SVG_NS, tag)
+  for (const [key, value] of Object.entries(attrs)) node.setAttribute(key, value)
+  return node
+}
+
+/** 星图：主星按 id 排序后均布在大圆上（稳定、不重叠），次星（流程图）在主星外侧扇形散开，
+ *  连线只连真实归属（业务→它的图）。点主星进业务页，点次星进阅读页。 */
+function buildStarMap(businesses) {
+  const svg = svgEl('svg', { viewBox: '0 0 1000 640', class: 'star-svg', role: 'img', 'aria-label': '业务星图' })
+  const sorted = [...businesses].sort((a, b) => a.id.localeCompare(b.id))
+  const cx = 500
+  const cy = 320
+  const radius = 225
+  sorted.forEach((business, index) => {
+    const angle = ((-90 + (index * 360) / sorted.length) * Math.PI) / 180
+    const bx = cx + radius * Math.cos(angle)
+    const by = cy + radius * Math.sin(angle)
+    const group = svgEl('g', { class: 'star-group' })
+    const charts = [...business.charts].sort((a, b) => a.id.localeCompare(b.id))
+    charts.forEach((chart, j) => {
+      const spread = ((j - (charts.length - 1) / 2) * 26 * Math.PI) / 180
+      const px = bx + 88 * Math.cos(angle + spread)
+      const py = by + 88 * Math.sin(angle + spread)
+      group.append(svgEl('line', { class: 'star-line', x1: bx, y1: by, x2: px, y2: py }))
+      const link = svgEl('a', { href: wsUrl(`/specdev-workbench/read/${encodeURIComponent(business.id)}/${encodeURIComponent(chart.id)}`) })
+      const title = svgEl('title')
+      title.textContent = chart.name
+      const dot = svgEl('circle', { class: 'star star-chart', cx: px, cy: py, r: 5, 'data-star': 'chart' })
+      link.append(title, dot)
+      group.append(link)
+    })
+    const bizLink = svgEl('a', { href: wsUrl(`/specdev-workbench/business/${encodeURIComponent(business.id)}`) })
+    const bizTitle = svgEl('title')
+    bizTitle.textContent = business.name
+    const glow = svgEl('circle', { class: 'star-glow', cx: bx, cy: by, r: 26 })
+    glow.style.animationDelay = `${index * 0.45}s`
+    const star = svgEl('circle', { class: 'star star-business', cx: bx, cy: by, r: 11, 'data-star': 'business', 'data-business': business.id })
+    // 名字放在主星靠圆心一侧：连线与次星都朝外，标签不会压到它们。
+    const label = svgEl('text', { class: 'star-label', x: bx - 42 * Math.cos(angle), y: by - 42 * Math.sin(angle), 'text-anchor': 'middle', 'dominant-baseline': 'middle' })
+    label.textContent = business.name
+    bizLink.append(bizTitle, glow, star, label)
+    group.append(bizLink)
+    svg.append(group)
+  })
+  return svg
+}
+
+/** 球阵：斐波那契球面均匀布点（按 key 排序，稳定），自转是自绘投影——深度决定大小、
+ *  透明度与层序。不做拖拽物理（小样的拖拽坐标坑不进产品），点球直接跳转。 */
+function createSphere(box, nodes) {
+  const sorted = [...nodes].sort((a, b) => a.key.localeCompare(b.key))
+  const count = sorted.length
+  const els = sorted.map((node) => {
+    const link = el('a', 'sphere-node')
+    link.href = node.href
+    link.dataset.kind = node.kind
+    const dot = el('span', 'sphere-dot')
+    const label = el('span', 'sphere-label')
+    label.textContent = node.label
+    link.append(dot, label)
+    link.title = node.label
+    box.append(link)
+    return link
+  })
+  const golden = 2.399963229728653
+  const points = sorted.map((node, i) => {
+    const y = 1 - (2 * (i + 0.5)) / count
+    const ring = Math.sqrt(Math.max(0, 1 - y * y))
+    const theta = i * golden
+    return { x: Math.cos(theta) * ring, y, z: Math.sin(theta) * ring }
+  })
+  let angle = 0
+  let running = false
+  let handle = 0
+  let frames = 0
+  function project() {
+    const width = box.clientWidth || 960
+    const height = box.clientHeight || 520
+    const cx = width / 2
+    const cy = height / 2
+    const radius = Math.min(width, height) * 0.36
+    const cos = Math.cos(angle)
+    const sin = Math.sin(angle)
+    points.forEach((point, i) => {
+      const x = point.x * cos - point.z * sin
+      const z = point.x * sin + point.z * cos
+      const depth = (z + 1) / 2
+      const node = els[i]
+      node.style.left = `${(cx + x * radius).toFixed(1)}px`
+      node.style.top = `${(cy + point.y * radius * 0.92).toFixed(1)}px`
+      node.style.zIndex = String(Math.round(depth * 100))
+      node.style.opacity = (0.35 + depth * 0.65).toFixed(2)
+      node.style.transform = `translate(-50%, -50%) scale(${(0.55 + depth * 0.75).toFixed(3)})`
+    })
+  }
+  function loop() {
+    angle += 0.0045
+    project()
+    frames += 1
+    handle = requestAnimationFrame(loop)
+  }
+  function start() {
+    if (running || typeof requestAnimationFrame !== 'function') return
+    running = true
+    handle = requestAnimationFrame(loop)
+  }
+  function stop() {
+    if (!running) return
+    running = false
+    cancelAnimationFrame(handle)
+  }
+  project()
+  return {
+    start,
+    stop,
+    project,
+    isRunning: () => running,
+    frameCount: () => frames,
+  }
+}
+
+async function main() {
+  if (workspaceParamEmpty) return renderEmptyWorkspaceParam()
+  let inventory
+  try {
+    inventory = await fetchJson(wsUrl('/specdev-workbench/api/inventory'))
+  } catch (error) {
+    if (error.repo) renderRepoLine(error.repo)
+    if (!renderRepoState(error)) showError(error.message)
+    return
+  }
+  if (inventory.code === 'repo-not-configured') return renderGuide(inventory)
+  renderRepoLine(inventory.repo)
+  document.title = pageTitle('业务展示', inventory.repo)
+  $('intro').textContent = inventory.project.description || inventory.project.name
+  const businesses = inventory.businesses
+  setStatus(`共 ${businesses.length} 个业务`, 'ok')
+
+  const listView = $('viewList')
+  if (businesses.length === 0) {
+    const empty = el('div', 'empty-state')
+    const h = el('h3')
+    h.textContent = '还没有可展示的业务'
+    const p = el('p')
+    p.textContent = '项目清单里添加业务资料后，本页的列表、星图与球阵会一起亮起来。'
+    empty.append(h, p)
+    listView.append(empty)
+    return
+  }
+
+  for (const [index, business] of businesses.entries()) listView.append(businessCard(business, index))
+  $('starBox').append(buildStarMap(businesses))
+
+  const nodes = []
+  for (const business of businesses) {
+    nodes.push({ key: `b/${business.id}`, kind: 'business', label: business.name, href: wsUrl(`/specdev-workbench/business/${encodeURIComponent(business.id)}`) })
+    for (const chart of business.charts) {
+      nodes.push({ key: `c/${business.id}/${chart.id}`, kind: 'chart', label: chart.name, href: wsUrl(`/specdev-workbench/read/${encodeURIComponent(business.id)}/${encodeURIComponent(chart.id)}`) })
+    }
+  }
+  const sphere = createSphere($('sphereBox'), nodes)
+  const motionAllowed = !window.matchMedia('(prefers-reduced-motion: reduce)').matches
+
+  const switcher = $('viewSwitch')
+  const startButton = $('sphereStart')
+  let current = storedView()
+  function syncSphereButton() {
+    startButton.hidden = motionAllowed || current !== 'sphere' || sphere.isRunning()
+  }
+  function setView(view) {
+    current = view
+    for (const button of switcher.querySelectorAll('[data-view]')) {
+      button.setAttribute('aria-pressed', String(button.dataset.view === view))
+    }
+    $('viewList').hidden = view !== 'list'
+    $('viewStar').hidden = view !== 'star'
+    $('viewSphere').hidden = view !== 'sphere'
+    if (view === 'sphere') {
+      sphere.project()
+      if (motionAllowed) sphere.start()
+    } else {
+      sphere.stop() // 切走即停渲染（星图小样第 6 条口径）
+    }
+    syncSphereButton()
+    storeView(view)
+  }
+  switcher.querySelectorAll('[data-view]').forEach((button) => {
+    button.addEventListener('click', () => setView(button.dataset.view))
+  })
+  startButton.addEventListener('click', () => {
+    sphere.start()
+    syncSphereButton()
+  })
+  document.addEventListener('visibilitychange', () => {
+    if (document.hidden) sphere.stop()
+    else if (current === 'sphere' && motionAllowed) sphere.start()
+    syncSphereButton()
+  })
+  switcher.hidden = false
+  setView(current)
+}
+
+main()