@dimina-kit/inspect 0.3.0-dev.20260711141929 → 0.4.0-dev.20260716153350

package/dist/wxml-extract.js

@@ -42,73 +42,27 @@ function resolveTemplateNameFromParent(instance) {
 function pascalToKebab(name) {
     return name.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
 }
-/**
- * Read the page's source path off Vue's provide/inject. dimina runtime.js 在
- * dd-page 的 setup() 里调用 `provide('path', path)`，Vue 把它存到
- * `instance.provides`。我们利用这个把页面节点的 tagName 从硬编码 `page`
- * 升级为页面全路径（如 `pages/index/index`），对齐微信开发者工具。
- */
-function resolvePagePath(instance) {
-    // dimina runtime 在 dd-page 的 setup 里 `instance.proxy.__page__ = true` 并
-    // `provide('path', path)`。两个标记同时具备才视为页面层级，避免 dd-page
-    // 的子节点继承 provides.path 后被误判（Vue 用 Object.create 链式 provides）。
-    const proxy = instance.proxy;
-    if (proxy?.__page__ !== true)
-        return null;
-    const provides = instance.provides;
-    const path = provides?.path;
-    if (typeof path !== 'string' || !path)
-        return null;
-    return path.startsWith('/') ? path.slice(1) : path;
-}
-/**
- * A NATIVE dimina custom component (a `usingComponents` entry) calls
- * `provide('path', componentPath)` in its setup (render runtime), so its
- * provided `path` DIFFERS from its parent's. A plain descendant inherits the
- * same provides object (identical `path`) and is not a boundary; a Taro template
- * wrapper (`dd-tpl-*`) never provides, so it never differs either. Comparing
- * against the parent's provided path therefore isolates exactly the native
- * component roots — matching WeChat, which shows each custom component as a node
- * tagged with its full registered path (with a synthetic `#shadow-root` added by
- * `wrapInShadowRoot` since the path contains `/`). Pages are handled earlier via
- * their authoritative `__page__` marker, so this only fires for components.
- */
-function resolveComponentPath(instance) {
-    const provides = instance.provides;
-    const path = provides?.path;
-    if (typeof path !== 'string' || !path)
-        return null;
-    const parent = instance.parent;
-    const parentProvides = parent?.provides;
-    if (path === parentProvides?.path)
-        return null;
-    return path.startsWith('/') ? path.slice(1) : path;
-}
-function resolveTagName(instance) {
+export function resolveTagName(instance) {
     const type = instance.type;
     if (!type)
         return 'unknown';
-    // 页面层级优先：dd-page 没有 __tagName/__name，且 home 页等无 usingComponents
-    // 的页面 type.components 为 undefined，会落到 resolveTemplateNameFromParent
-    // 回到 'page'。在那之前直接用 provide('path') 的路径升级 tag 名。
-    const pagePath = resolvePagePath(instance);
-    if (pagePath)
-        return pagePath;
-    // Native custom-component boundary → tag with its full registered path (WeChat
-    // parity). Must precede the __tagName/__name/dd- shortening below, which would
-    // otherwise collapse `dd-foo` to the bare `foo` and lose the path.
-    const componentPath = resolveComponentPath(instance);
-    if (componentPath)
-        return componentPath;
+    // Authoritative source-path identity: the render runtime sets each compiled
+    // page/custom-component's Vue `name` to its miniprogram module path. A name
+    // containing `/` IS that source path — trust it directly (WeChat parity).
+    // It is per-type (not inherited via provides), so a descendant never leaks its
+    // ancestor's path, and it needs no live provide/inject chain to reconstruct.
+    const nameId = (type.name || type.__name);
+    if (nameId && nameId.includes('/')) {
+        return nameId.startsWith('/') ? nameId.slice(1) : nameId;
+    }
     if (typeof type.__tagName === 'string')
         return type.__tagName;
     const name = (type.__name || type.name);
     if (!name) {
-        // A nameless component carrying a `__scopeId` is a compiled page, custom
-        // component, or framework template wrapper. The page is already resolved
-        // above via its authoritative `__page__` marker, so by here it is NOT a
-        // page — recover the registered tag (e.g. a Taro `taro_tmpl`/`tmpl_0_3`
-        // wrapper) and fall back to `template`. Defaulting to `page` here would
+        // A nameless component carrying a `__scopeId` is a framework template
+        // wrapper (e.g. a Taro `taro_tmpl`/`tmpl_0_3`) — pages and custom components
+        // carry a path `name` and are resolved above. Recover the registered tag and
+        // fall back to `template`; never default to `page` here, which would
         // mislabel every such wrapper as a second page root.
         if (type.__scopeId)
             return resolveTemplateNameFromParent(instance) || 'template';
@@ -184,6 +138,20 @@ function getElementSid(instance) {
         return sid;
     return registerSyntheticSid(el);
 }
+/**
+ * The absolute component path a `dd-wrapper` carries in its `name` prop/attr, or
+ * null. dimina wraps EVERY custom-component template root in
+ * `<dd-wrapper name="/components/foo/foo">`; the path always starts with `/`,
+ * which a user-authored `name` attr essentially never does.
+ */
+function wrapperPathName(instance) {
+    for (const raw of [instance.props, instance.attrs]) {
+        const n = raw?.name;
+        if (typeof n === 'string' && n.startsWith('/'))
+            return n;
+    }
+    return null;
+}
 function isTransparentComponent(instance, tagName) {
     if (tagName === 'unknown')
         return true;
@@ -192,6 +160,16 @@ function isTransparentComponent(instance, tagName) {
     // not user content — pass its children straight through.
     if (FRAMEWORK_TEMPLATE_RE.test(tagName))
         return true;
+    // dimina wraps every custom-component template root in a
+    // `<dd-wrapper name="/path">`. Under the name-path model the ENCLOSING
+    // component instance already carries that same source path as its own node
+    // (its Vue `name` IS the path), so surfacing the wrapper too would emit a
+    // SECOND identical path node — the doubled `<components/foo/foo>` layer. The
+    // wrapper is redundant scaffolding: pass its children through. Gated on a
+    // path-shaped `name` so a user-authored `<wrapper name="x">` is never
+    // swallowed (dimina paths always start with `/`).
+    if (tagName === 'wrapper' && wrapperPathName(instance))
+        return true;
     if (tagName === 'template') {
         const props = instance.props;
         const is = props?.is;
@@ -303,48 +281,6 @@ function extractChildrenFromVNode(vnode, depth) {
     }
     return result;
 }
-/**
- * Reverse-map Dimina's `<wrapper name="/components/foo/foo">` (used to host
- * every user-defined component) back to the source-level tag the user wrote
- * in WXML (e.g. `<foo>`).
- *
- * The wrapper carries the registered component path in its `name` Vue prop.
- * By convention (also followed by miniprogram tooling), the registered key is
- * the last path segment, optionally stripping a trailing `/index`. We can't
- * see the page's `usingComponents` map from inside the Vue instance, so this
- * convention-based recovery is best-effort: if the user picked a different
- * registration key than the directory name (e.g. `usingComponents:
- * { myCounter: '/components/counter/counter' }`), the panel will show
- * `counter`, not `myCounter`.
- *
- * The path heuristic also resolves a name-collision risk: a user-written
- * `<counter name="x">` would land in the same `attrs.name` slot as the
- * wrapper-internal path. We only unwrap when the value looks like an absolute
- * component path (leading `/`), which dimina always emits but a user would
- * almost never type as a literal attr.
- */
-function unwrapCustomComponent(node) {
-    if (node.tagName !== 'wrapper')
-        return node;
-    const path = node.attrs?.name;
-    if (typeof path !== 'string' || !path.startsWith('/'))
-        return node;
-    // 去掉前导 `/` 后保留原路径形式（保留所有斜杠，不做 kebab/dash 转换）。
-    // 仅当路径以 `/index` 结尾且剥离后仍至少剩一段时才剥（`/index` 单独存在则
-    // 退回 wrapper，避免出现空 tagName）。
-    const stripped = path.replace(/^\//, '');
-    const withoutIndex = stripped.endsWith('/index') ? stripped.slice(0, -'/index'.length) : stripped;
-    const recovered = withoutIndex || stripped;
-    if (!recovered || recovered === 'index')
-        return node;
-    const nextAttrs = {};
-    for (const [k, v] of Object.entries(node.attrs)) {
-        if (k === 'name')
-            continue;
-        nextAttrs[k] = v;
-    }
-    return { ...node, tagName: recovered, attrs: nextAttrs };
-}
 /**
  * 把"用户授权"层级（页面 / 自定义组件，tagName 以路径形式呈现，含 `/`）
  * 的 children 包一层合成 `#shadow-root`，对齐微信开发者工具：组件本身
@@ -377,5 +313,5 @@ export function walkInstance(instance, depth) {
     const sid = getElementSid(instance);
     if (sid)
         node.sid = sid;
-    return wrapInShadowRoot(unwrapCustomComponent(node));
+    return wrapInShadowRoot(node);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimina-kit/inspect",
-  "version": "0.3.0-dev.20260711141929",
+  "version": "0.4.0-dev.20260716153350",
   "description": "Host-agnostic WXML tree extraction and inspection for dimina render layers: Vue runtime walk, stable-id registry, mutation-observing inspector, and a React tree panel.",
   "keywords": [
     "dimina",
@@ -62,6 +62,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@uiw/react-json-view": "2.0.0-alpha.41"
+  },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "check-types": "tsc --noEmit -p tsconfig.json",

package/src/appdata-accumulator.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for AppDataAccumulator.pageData(bridgeId).
+ *
+ * Contract:
+ *   - Returns a single shallow-merged object combining `entry.data` of EVERY
+ *     cache entry whose key starts with `${bridgeId}/`.
+ *   - Returns {} for an unknown bridgeId and after clearBridge(bridgeId).
+ *   - Only that bridge's entries are merged (other bridgeIds excluded).
+ *
+ * These tests pin page reactive-data reads (miniprogram-automator Page.getData)
+ * off the central accumulator.
+ */
+import { describe, expect, it } from 'vitest'
+import { AppDataAccumulator } from './appdata-accumulator.js'
+
+/** Apply a page-instance init (full initial state) for a bridge. */
+function applyInit(
+  acc: AppDataAccumulator,
+  bridgeId: string,
+  moduleId: string,
+  componentPath: string,
+  data: Record<string, unknown>,
+): void {
+  acc.apply({ mode: 'init', bridgeId, moduleId, componentPath, data })
+}
+
+/** Apply a setData patch (merge onto previous) for a bridge/module. */
+function applyPatch(
+  acc: AppDataAccumulator,
+  bridgeId: string,
+  moduleId: string,
+  data: Record<string, unknown>,
+): void {
+  acc.apply({ mode: 'patch', bridgeId, moduleId, data })
+}
+
+describe('AppDataAccumulator.pageData', () => {
+  it('merges init + setData patch into the current reactive state for the bridge', () => {
+    const acc = new AppDataAccumulator()
+    applyInit(acc, 'b1', 'page_1', 'pages/index/index', { count: 0, title: 'hi' })
+    applyPatch(acc, 'b1', 'page_1', { count: 5 })
+
+    // count reflects the patch; title survives from init (setData merge semantics)
+    expect(acc.pageData('b1')).toEqual({ count: 5, title: 'hi' })
+  })
+
+  it('shallow-merges multiple page module entries belonging to the same bridge', () => {
+    const acc = new AppDataAccumulator()
+    applyInit(acc, 'b1', 'page_1', 'pages/index/index', { a: 1 })
+    // A second page module on the same bridge contributes its own keys.
+    applyInit(acc, 'b1', 'page_2', 'pages/index/index', { b: 2 })
+
+    expect(acc.pageData('b1')).toEqual({ a: 1, b: 2 })
+  })
+
+  it('isolates bridges — only the requested bridge\'s entries are merged', () => {
+    const acc = new AppDataAccumulator()
+    applyInit(acc, 'b1', 'page_1', 'pages/index/index', { name: 'amy' })
+    applyInit(acc, 'b2', 'page_1', 'pages/other/other', { name: 'bob' })
+    applyPatch(acc, 'b2', 'page_1', { extra: true })
+
+    expect(acc.pageData('b1')).toEqual({ name: 'amy' })
+    expect(acc.pageData('b2')).toEqual({ name: 'bob', extra: true })
+    // b1's result must not contain b2's keys.
+    expect(acc.pageData('b1')).not.toHaveProperty('extra')
+  })
+
+  it('returns {} for an unknown bridgeId (no entries)', () => {
+    const acc = new AppDataAccumulator()
+    applyInit(acc, 'b1', 'page_1', 'pages/index/index', { count: 0 })
+
+    expect(acc.pageData('does-not-exist')).toEqual({})
+  })
+
+  it('returns {} after clearBridge evicts the bridge', () => {
+    const acc = new AppDataAccumulator()
+    applyInit(acc, 'b1', 'page_1', 'pages/index/index', { count: 3 })
+    expect(acc.pageData('b1')).toEqual({ count: 3 })
+
+    acc.clearBridge('b1')
+    expect(acc.pageData('b1')).toEqual({})
+  })
+})

package/src/appdata-accumulator.ts

@@ -0,0 +1,246 @@
+/**
+ * Framework-agnostic AppData accumulator.
+ *
+ * The dimina runtime emits two service→render messages relevant to the AppData
+ * panel, identical in shape on BOTH container paths:
+ *   • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
+ *     — each `data` is a partial setData patch.
+ *   • instance init: `type === 'page_*'`, body `{bridgeId, path, data}` with the
+ *     COMPLETE initial state.
+ *
+ * Hosts differ only in where they tap that stream — an Electron preload
+ * sniffing Worker `message` events, a main-process service→render forward, or
+ * a same-origin web workbench observing the pageFrame's Worker. Every tap
+ * feeds this one accumulator so the decode/merge/page-only/init-gate policy
+ * can't drift between hosts.
+ */
+
+/**
+ * The AppData snapshot — the full, cumulative panel state.
+ *
+ * - `bridges` lists every page bridge in chronological (insertion) order, each
+ *   carrying its page route (`pagePath`), so renderer tabs render in a stable
+ *   sequence.
+ * - `entries` maps `bridgeId → (componentPath | moduleId) → setData state`.
+ */
+export interface AppDataSnapshot {
+  bridges: Array<{ id: string; pagePath: string | null }>
+  entries: Record<string, Record<string, unknown>>
+}
+
+export type DecodedEntry =
+  | { mode: 'patch'; bridgeId: string; moduleId: string; data: unknown }
+  | {
+      mode: 'init'
+      bridgeId: string
+      moduleId: string
+      componentPath: string
+      data: Record<string, unknown>
+    }
+
+/** Normalized input to the accumulator (built from a DecodedEntry or the hook). */
+export interface AppDataInput {
+  bridgeId?: string
+  moduleId?: string
+  componentPath?: string
+  data?: unknown
+  mode?: 'init' | 'patch'
+}
+
+interface CacheEntry {
+  componentPath?: string
+  data: Record<string, unknown>
+}
+
+/** Parse a service/worker message payload; a non-string is passed through as-is. */
+function parseMessagePayload(message: unknown): unknown {
+  if (typeof message !== 'string') return message
+  try {
+    return JSON.parse(message)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Decode a `ub` (update batch) body into patch entries, PAGE modules only —
+ * component-module updates are dropped (see `decodeWorkerMessage`).
+ */
+function decodeUpdateBatchBody(rawBody: unknown): DecodedEntry[] | null {
+  const body = rawBody as { bridgeId?: unknown; updates?: unknown } | null
+  if (!body || typeof body !== 'object') return null
+  if (typeof body.bridgeId !== 'string' || !Array.isArray(body.updates)) return null
+  const out: DecodedEntry[] = []
+  for (const u of body.updates as Array<{ moduleId?: unknown; data?: unknown }>) {
+    if (!u || typeof u.moduleId !== 'string') continue
+    if (!u.moduleId.startsWith('page_')) continue
+    out.push({ mode: 'patch', bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data })
+  }
+  return out.length > 0 ? out : null
+}
+
+/** Decode a `page_*` instance-init body into its single init entry. */
+function decodePageInitBody(moduleId: string, rawBody: unknown): DecodedEntry[] | null {
+  const body = rawBody as { bridgeId?: unknown; path?: unknown; data?: unknown } | null
+  if (!body || typeof body !== 'object') return null
+  if (typeof body.bridgeId !== 'string' || typeof body.path !== 'string') return null
+  if (!body.data || typeof body.data !== 'object') return null
+  return [{
+    mode: 'init',
+    bridgeId: body.bridgeId,
+    moduleId,
+    componentPath: body.path,
+    data: body.data as Record<string, unknown>,
+  }]
+}
+
+/**
+ * Decode a service→render message into AppData entries, or null when it is not
+ * AppData-relevant. Policy: surface PAGE entries only — component entries are
+ * dropped (they sometimes flow on a bridge id distinct from their owning page's
+ * and never receive pageUnload, which would manifest as ghost tabs).
+ */
+export function decodeWorkerMessage(message: unknown): DecodedEntry[] | null {
+  const payload = parseMessagePayload(message)
+  if (!payload || typeof payload !== 'object') return null
+  const record = payload as { type?: unknown; body?: unknown }
+
+  if (record.type === 'ub') return decodeUpdateBatchBody(record.body)
+  if (typeof record.type === 'string' && record.type.startsWith('page_')) {
+    return decodePageInitBody(record.type, record.body)
+  }
+  return null
+}
+
+/** main→worker direction: container signals page teardown so cache can evict. */
+export function decodeOutgoingMessage(message: unknown): { type: string; bridgeId?: string } | null {
+  const payload = parseMessagePayload(message)
+  if (!payload || typeof payload !== 'object') return null
+  const r = payload as { type?: unknown; body?: { bridgeId?: unknown } | null }
+  if (typeof r.type !== 'string') return null
+  return {
+    type: r.type,
+    bridgeId: typeof r.body?.bridgeId === 'string' ? r.body.bridgeId : undefined,
+  }
+}
+
+/** Convert a decoded entry to the normalized accumulator input. */
+export function decodedToInput(entry: DecodedEntry): AppDataInput {
+  const input: AppDataInput = {
+    bridgeId: entry.bridgeId,
+    moduleId: entry.moduleId,
+    data: entry.data,
+    mode: entry.mode,
+  }
+  if (entry.mode === 'init') input.componentPath = entry.componentPath
+  return input
+}
+
+/**
+ * Cumulative per-(bridgeId, moduleId) setData state. Pure data structure — no
+ * Worker / IPC / DOM. Callers own transport (publish/emit) and the automation
+ * mirror.
+ */
+export class AppDataAccumulator {
+  private readonly cache = new Map<string, CacheEntry>()
+  // Bridges in insertion order — drives the `bridges` array (stable tab order).
+  private readonly bridgeOrder: string[] = []
+  // Page path per bridge: set from `page_*` init's body.path (the page route).
+  private readonly bridgePagePath = new Map<string, string>()
+
+  private recordBridge(bridgeId: string): void {
+    if (!this.bridgeOrder.includes(bridgeId)) this.bridgeOrder.push(bridgeId)
+  }
+
+  /**
+   * Apply one entry. Returns true if it was accepted (a mutation worth
+   * republishing), false if dropped (missing ids, or the init-gate).
+   */
+  apply(input: AppDataInput): boolean {
+    if (!input.bridgeId || !input.moduleId) return false
+    // Drop ub patches whose bridge has never been initialised. dimina
+    // dispatches pageUnload → onUnload, whose setData produces a late `ub`
+    // arriving AFTER clearBridge; without this gate it would resurrect the
+    // unloaded bridge as a ghost tab.
+    if (input.mode !== 'init' && !this.bridgePagePath.has(input.bridgeId)) return false
+    const key = `${input.bridgeId}/${input.moduleId}`
+    const prev = this.cache.get(key)
+    const incoming = input.data && typeof input.data === 'object'
+      ? (input.data as Record<string, unknown>)
+      : {}
+    // init = full-state replace; patch = merge into previous (setData semantics)
+    const merged = input.mode === 'init'
+      ? { ...incoming }
+      : { ...(prev?.data ?? {}), ...incoming }
+    const componentPath = input.componentPath ?? prev?.componentPath
+    const next: CacheEntry = componentPath !== undefined
+      ? { componentPath, data: merged }
+      : { data: merged }
+    this.cache.set(key, next)
+    this.recordBridge(input.bridgeId)
+    if (input.mode === 'init' && input.moduleId.startsWith('page_') && input.componentPath) {
+      this.bridgePagePath.set(input.bridgeId, input.componentPath)
+    }
+    return true
+  }
+
+  /** Evict every entry for a bridge (page teardown). */
+  clearBridge(bridgeId: string): void {
+    const prefix = `${bridgeId}/`
+    for (const key of [...this.cache.keys()]) {
+      if (key.startsWith(prefix)) this.cache.delete(key)
+    }
+    const idx = this.bridgeOrder.indexOf(bridgeId)
+    if (idx >= 0) this.bridgeOrder.splice(idx, 1)
+    this.bridgePagePath.delete(bridgeId)
+  }
+
+  /** The full cumulative snapshot for the panel. */
+  snapshot(): AppDataSnapshot {
+    const bridges: Array<{ id: string; pagePath: string | null }> = []
+    for (const id of this.bridgeOrder) {
+      bridges.push({ id, pagePath: this.bridgePagePath.get(id) ?? null })
+    }
+    const entries: Record<string, Record<string, unknown>> = {}
+    for (const [key, entry] of this.cache) {
+      const slash = key.indexOf('/')
+      if (slash < 0) continue
+      const bridgeId = key.slice(0, slash)
+      const moduleId = key.slice(slash + 1)
+      if (!entries[bridgeId]) entries[bridgeId] = {}
+      const displayKey = entry.componentPath ?? moduleId
+      entries[bridgeId][displayKey] = entry.data
+    }
+    return { bridges, entries }
+  }
+
+  /**
+   * The current reactive page state for a bridge: shallow-merge of `entry.data`
+   * across every cache entry whose key starts with `${bridgeId}/`, in insertion
+   * order (later entries win on key conflicts). `{}` when no entries match
+   * (unknown bridge / after clearBridge). Pure, no side effects.
+   */
+  pageData(bridgeId: string): Record<string, unknown> {
+    const merged: Record<string, unknown> = {}
+    for (const [key, entry] of this.cache) {
+      const slash = key.indexOf('/')
+      if (slash < 0) continue
+      if (key.slice(0, slash) !== bridgeId) continue
+      Object.assign(merged, entry.data)
+    }
+    return merged
+  }
+
+  /** Flat `key → data` map for the `__simulatorData.getAppdata()` mirror. */
+  flat(): Record<string, unknown> {
+    const data: Record<string, unknown> = {}
+    for (const [key, entry] of this.cache) data[key] = entry.data
+    return data
+  }
+
+  clear(): void {
+    this.cache.clear()
+    this.bridgeOrder.length = 0
+    this.bridgePagePath.clear()
+  }
+}

package/src/appdata-panel-view-empty-state.test.tsx

@@ -0,0 +1,46 @@
+/**
+ * Contract: AppDataPanel takes an `isRuntimeRunning?: boolean` prop (the
+ * integration layer computes it as `runtimeStatus?.phase === 'running'`).
+ * When the session is NOT running, the empty state must render distinct copy
+ * that says the session isn't running (must contain "未运行" or "启动") —
+ * NOT the existing "暂无页面数据" wording, which would otherwise print even
+ * while the simulator is stuck on a launch failure or a crash and
+ * misleadingly imply "the app is fine, it just has no page data yet".
+ *
+ * Once running, the existing "暂无页面数据（仅显示 Page 级 data）" copy must
+ * be unchanged (regression guard).
+ */
+import { describe, it, expect } from 'vitest'
+import { render } from '@testing-library/react'
+import { AppDataPanel, type AppDataPanelState as AppDataState } from './appdata-panel-view.js'
+
+const EMPTY_STATE: AppDataState = { bridges: [], activeBridgeId: null, entries: {} }
+
+function makeProps(isRuntimeRunning: boolean): Parameters<typeof AppDataPanel>[0] {
+  return {
+    state: EMPTY_STATE,
+    onSelectBridge: () => {},
+    isRuntimeRunning,
+  }
+}
+
+describe('AppDataPanel: empty-state copy reflects whether the session is actually running', () => {
+  it('shows a "not running" empty state (contains 未运行 or 启动) when the session never reached running', () => {
+    const { getByTestId } = render(<AppDataPanel {...makeProps(false)} />)
+    const text = getByTestId('appdata-panel').textContent ?? ''
+    expect(
+      text.includes('未运行') || text.includes('启动'),
+      `expected empty-state text to signal the session is not running; got: "${text}"`,
+    ).toBe(true)
+  })
+
+  it('keeps the existing "暂无页面数据" copy (unchanged) once running', () => {
+    const { getByTestId, getByText } = render(<AppDataPanel {...makeProps(true)} />)
+    expect(getByText('暂无页面数据（仅显示 Page 级 data）')).toBeTruthy()
+    const text = getByTestId('appdata-panel').textContent ?? ''
+    expect(
+      text.includes('未运行'),
+      'a genuinely-empty RUNNING session must not be painted with the "not running" copy',
+    ).toBe(false)
+  })
+})

package/src/appdata-panel-view.test.tsx

@@ -0,0 +1,49 @@
+/**
+ * AppDataPanel — no refresh button.
+ *
+ * The panel is now realtime-pushed (main pushes `SimulatorAppDataChannel.Event`
+ * on every service→render setData) and ready-seeded (`useNativeChannelSnapshot`'s
+ * `enabled: ready` effect), so the panel's own "↻ 刷新" button is redundant and
+ * must be removed. The panel no longer takes an `onRefresh` prop at all — seeding
+ * is driven at the tab level (`DockDebugTab`), not by the panel — so this test
+ * pins that the panel itself renders no user-facing refresh control.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { render } from '@testing-library/react'
+import { AppDataPanel, type AppDataPanelState as AppDataState } from './appdata-panel-view.js'
+
+function makeState(overrides: Partial<AppDataState> = {}): AppDataState {
+  return {
+    bridges: [{ id: 'b1', pagePath: 'pages/index/index' }],
+    activeBridgeId: 'b1',
+    entries: { b1: { 'pages/index/index': { count: 1 } } },
+    ...overrides,
+  }
+}
+
+describe('AppDataPanel: no refresh button', () => {
+  it('does not render a button whose text contains "刷新"', () => {
+    const { container } = render(
+      <AppDataPanel state={makeState()} onSelectBridge={vi.fn()} />,
+    )
+
+    const refreshButtons = Array.from(container.querySelectorAll('button')).filter((b) =>
+      (b.textContent ?? '').includes('刷新'),
+    )
+    expect(refreshButtons).toHaveLength(0)
+  })
+
+  it('does not render a refresh button even with no bridges (empty state)', () => {
+    const { container } = render(
+      <AppDataPanel
+        state={makeState({ bridges: [], activeBridgeId: null, entries: {} })}
+        onSelectBridge={vi.fn()}
+      />,
+    )
+
+    const refreshButtons = Array.from(container.querySelectorAll('button')).filter((b) =>
+      (b.textContent ?? '').includes('刷新'),
+    )
+    expect(refreshButtons).toHaveLength(0)
+  })
+})