@mzzsfy/dsh-stock-assistant 0.3.1 → 0.3.2

package/README.md

@@ -2,7 +2,7 @@
 
 DSH 全局股票工具。左侧“股票”入口打开独立主页面，无会话也可使用。切换、关闭 DSH 会话或临时打开其他工具，不会清除股票工具的搜索、详情、排序、滚动位置和设置草稿。
 
-支持八个市场（沪/深 A 股、港股、美股 NYSE/NASDAQ、日经、韩证、伦敦）：自选、名称/代码/拼音首字母搜索（多市场候选带币种徽标）、K 线图表（分时/日K/周K/月K，MA5/10/20/60、成交量副图、昨收参考线，lightweight-charts 渲染）、基础详情、别名、置顶、上下移动、涨跌排序、删除后撤销、手动刷新、暂停采集，以及数据源与能力路由设置（含"一键为已启用市场配置K线"）。不包含交易、持仓、资讯或价格提醒。
+支持八个市场（沪/深 A 股、港股、美股 NYSE/NASDAQ、日经、韩证、伦敦）：自选、名称/代码/拼音首字母搜索（多市场候选带币种徽标）、分组（置顶/各组/未分组常显段头，带组内涨跌统计与折叠；分组与排序正交，全局排序只决定组内顺序；悬浮窗勾选面板同源分区、可整组勾选）、K 线图表（分时/日K/周K/月K，MA/EMA/BOLL/BBI 可分别开关、成交量副图、昨收/价格标记/区间高低参考线，lightweight-charts 渲染）、悬浮盯盘（列表与图形双模式、只盯勾选的标的、可拖动、常驻在所有面板之上）、基础详情、别名、置顶、上下移动、涨跌排序、删除后撤销、手动刷新、暂停采集，以及数据源与能力路由设置（含"一键为已配置市场配置K线"）。不包含交易、持仓、资讯或价格提醒。
 
 ## 数据结构与持久化
 
@@ -18,11 +18,13 @@ DSH 全局股票工具。左侧“股票”入口打开独立主页面，无会
 
 具体介质路径由宿主的 storage backend 决定。本插件不向会话存储写数据。报价仅保留在 Host 内存中；搜索、详情、设置草稿等浏览状态由每个浏览器页面的运行时持有，刷新浏览器会重建这些临时状态。
 
+**浏览器本地另存两项显示偏好**，不进 `control/root`：悬浮盯盘的开关/位置/勾选目标（`ssb-floating`）与 K 线辅助线开关（`ssb-guides`）。这两项都是纯客户端显示状态，跟着屏幕与个人习惯走，多设备之间没有同步价值；放进宿主 `preferences` 的话，每加一个开关都要改协议 schema 并重启宿主才能生效，收益不成比例。代价是它们不随账号同步、清空站点数据会丢。刷新间隔与涨跌配色仍留在宿主侧，因为那两项影响上游请求节奏与全局显示语义。业务数据（自选、成本、别名、分组、数据源与路由）一律只走宿主存储。
+
 写操作在单一队列中执行，并携带版本及操作 ID。持久化成功后才发布；版本冲突保留用户输入并要求重新确认，写盘失败保留原数据。删除撤销有效期为8秒，恢复到当前列表原邻居附近，不回滚别页修改。损坏的权威记录会阻止激活，不会静默清空自选。
 
 ## 初次使用
 
-全新安装即内置默认数据源：免凭据东财公开源（保守预算 60 次/分），沪深市场已配好目录/搜索/报价三条路由，无需任何注册。打开后即可「检查所有来源能力」→ 保存 → 同步目录 → 用「浏览市场」翻页浏览全市场证券并直接加自选，或按代码/中文名/拼音首字母搜索。
+全新安装即内置默认数据源：免凭据东财公开源（保守预算 60 次/分），八个市场的目录、搜索、报价、K 线四条能力全部配好，无需任何注册。打开后即可「检查所有来源能力」→ 保存 → 同步目录 → 用「浏览市场」翻页浏览全市场证券并直接加自选，或按代码/中文名/拼音首字母搜索。日经、韩证、伦敦三个市场由东财全球搜索与目录页覆盖，其成交额字段来源恒给 0，界面按缺失呈现而不是显示「0」。
 
 - 顶栏「浏览市场」提供无目的浏览：按市场分页查看全部 A 股，行内一键加自选；目录未同步时页内有同步引导。
 - 搜索在目录未就绪时不再死路：错误提示带「前往浏览市场」直达入口。
@@ -48,11 +50,12 @@ Tushare 的 `rt_k`、`stock_basic`、`trade_cal` 权限分别由账号决定。
 | 适配器 | 能力 | 凭据 | 边界 |
 | --- | --- | --- | --- |
 | `tushare` | quotes / catalog / calendar | Host 环境变量 token | 唯一有正式权限表、配额文档与服务协议的渠道；三种能力可分开路由 |
-| `tencent` | 仅 quotes | 免凭据 | 公开网页接口；非官方、无 SLA，协议随时可能变化 |
-| `sina` | 仅 quotes | 免凭据 | 同上；价格恒三位小数，适配器裁剪到分 |
-| `eastmoney` | quotes / catalog / search | 免凭据 | 同上；目录分页抓全量（单市场约2500只，页频受限流退避约束），联想搜索支持中文/代码/首字母拼音 |
+| `tencent` | quotes / kline | 免凭据 | 公开网页接口；非官方、无 SLA，协议随时可能变化 |
+| `sina` | quotes / catalog | 免凭据 | 同上；价格恒三位小数，适配器裁剪到分；目录仅沪深 |
+| `eastmoney` | quotes / catalog / search / kline | 免凭据 | 同上；目录分页抓全量（单市场约2500只，页频受限流退避约束），联想搜索支持中文/代码/首字母拼音；K 线含分时与日/周/月，分时时间戳统一按北京时间解析 |
+| `xueqiu` | quotes | 免凭据（匿名 token） | 同上；可混装多市场，额外提供换手率与市值 |
 
-**零注册全流程**：只添加 `eastmoney` 实例（设置页选适配器即标"免凭据"，默认保守预算 60 次/分），给沪深市场配 catalog/search/quotes 三能力，检查→保存→同步目录→搜索添加→看行情，全程不需要任何账户。日历能力仅 Tushare 提供；缺日历时插件按"未知交易状态"保守采集，功能不受阻。
+**零注册全流程**：只添加 `eastmoney` 实例（设置页选适配器即标"免凭据"，默认保守预算 60 次/分），八个市场各配 catalog/search/quotes/kline 四条路由，检查→保存→同步目录→搜索添加→看行情，全程不需要任何账户。日历能力仅 Tushare 提供；缺日历时插件按"未知交易状态"保守采集，功能不受阻。
 
 混合路由：可把沪深行情分别路由到不同来源（沪市腾讯、深市东财、新浪备用等），目录/搜索用东财、日历用 Tushare——全部在设置页按市场/能力勾选。同一报价的现价、昨收、涨跌和时间始终来自同一适配器，不混拼字段。
 
@@ -66,7 +69,7 @@ Tushare 的 `rt_k`、`stock_basic`、`trade_cal` 权限分别由账号决定。
 
 同额度组顺序执行，上游启动间隔至少1秒；最多两个额度组并发。总账号、能力子额度、每日额度和证券计费额度共同约束请求。网络错误指数退避；429遵守 Retry-After；AUTH/PERMISSION/BAD_PAYLOAD暂停该能力，检查或修改后恢复。已知休市/午休不持续采集，日历缺失按未知状态保守采集。
 
-HTTP 路径前缀 `/api/stock-sidebar`：`snapshot/search/watchlist/preferences/provider-check/configuration/catalog-sync/route-selection/refresh`。写接口均为POST，读接口GET。普通请求上限10秒、单次上游8秒；目录同步30秒，多能力检查最多60秒。刷新直接等待批次并回快照，同价也有获取时间回执。周期启动下界同时考虑用户周期与来源额度。
+HTTP 路径前缀 `/api/stock-assistant`：`snapshot/search/watchlist/preferences/provider-check/configuration/catalog-sync/route-selection/refresh`。写接口均为POST，读接口GET。普通请求上限10秒、单次上游8秒；目录同步30秒，多能力检查最多60秒。刷新直接等待批次并回快照，同价也有获取时间回执。周期启动下界同时考虑用户周期与来源额度。
 
 通知复用 `@mzzsfy/dsh-common-tools` 的页面共享 WS，不创建股票专用 socket。失效通知与快照拉取分别合并；快照单飞、至少1秒启动间隔，失败不自循环重试。页面需求通过同一总线续租，不以 HTTP 心跳维持。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mzzsfy/dsh-stock-assistant",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "股票单页面工具：独立于会话的自选、多平台数据路由与行情查看",
   "type": "module",
   "main": "src/index.js",
@@ -22,7 +22,9 @@
     "compatibility": {
       "dshReleases": {
         "0.2.1-rc.2": "compatible",
-        "0.2.1-rc.3": "compatible"
+        "0.2.1-rc.3": "compatible",
+        "0.2.1-rc.5": "compatible",
+        "0.2.2-rc.1": "compatible"
       }
     }
   },
@@ -40,6 +42,7 @@
   },
   "files": [
     "src",
+    "vendor",
     "cordis.patch.yml",
     "README.md",
     "兼容性测试.md"

package/src/application.mjs

@@ -6,6 +6,7 @@ import { tushare } from './providers/tushare.mjs'
 import { tencent } from './providers/tencent.mjs'
 import { sina } from './providers/sina.mjs'
 import { eastmoney } from './providers/eastmoney.mjs'
+import { xueqiu } from './providers/xueqiu.mjs'
 import { openState, digest } from './state.mjs'
 import { parseConfiguration, preferencesSchema, defaultConfig, klineQuerySchema } from './schemas.mjs'
 import { createWatchlistService } from './service.mjs'
@@ -18,8 +19,12 @@ import { createKlineCache } from './kline-cache.mjs'
 import { fail, parseSecurityId, MARKET_META } from './market-model.mjs'
 const WINDOW = 5 * 60 * 1000
 const US_SYMBOL_TTL = 24 * 60 * 60 * 1000
-export async function createApplication({ storageDomain, providers = [tushare, tencent, sina, eastmoney], publish = () => {}, env = process.env, fetch = globalThis.fetch, now = Date.now, timers = globalThis, vendorAvailable = true }) {
+const US_SYMBOL_LIMIT = 500
+const PROBE_LIMIT = 512
+export async function createApplication({ storageDomain, providers = [tushare, tencent, sina, eastmoney, xueqiu], publish = () => {}, env = process.env, fetch = globalThis.fetch, now = Date.now, timers = globalThis, vendorAvailable = true }) {
   const serverEpoch = randomUUID(), checks = new Map()
+  // 目标粒度探针缓存: instanceId:capability:market → {status, until}; 配置保存校验按目标增量引用, 不随无关字段改动失效
+  const probeCache = new Map()
   let snapshotSeq = 0, stopped = false, collector, catalog, demand
   const usSymbols = new Map()
   const touched = () => snapshotSeq++
@@ -46,7 +51,9 @@ export async function createApplication({ storageDomain, providers = [tushare, t
     const wanted = demand.active(), opening = wanted && !hadDemand; hadDemand = wanted
     if (wanted) {
       ensureCaches()
-      if (opening) collector?.refresh().catch(() => {})
+      // 缓存新鲜时进入面板不重复打上游(限流主因); 过期才拉取, 定时器照常量节奏维持
+      const freshFor = (getControl().preferences?.refreshSeconds ?? 15) * 1000
+      if (opening && !collector?.freshWithin(freshFor)) collector?.refresh().catch(() => {})
       collector?.reconcile()
     } else collector?.cancelIdle()
   }, now, timers)
@@ -63,6 +70,8 @@ export async function createApplication({ storageDomain, providers = [tushare, t
     const caps = z.array(z.enum(['quotes', 'catalog', 'search', 'calendar', 'kline'])).min(1).max(5).parse(input.capabilities)
     const at = now()
     for (const [id, check] of checks) if (check.until <= at) checks.delete(id)
+    // 过期目标直接淘汰: 键空间随实例/市场/能力组合有界, 但不留过期条目占位
+    for (const [key, entry] of probeCache) if (entry.until <= at) probeCache.delete(key)
     if (checks.size >= 64) fail('CHECK_LIMIT', '检查请求过多，请稍后重试', 429)
     const results = []
     for (const route of config.routes.filter(r => caps.includes(r.capability))) for (const target of [route.primaryInstanceId, ...route.fallbackInstanceIds]) {
@@ -70,10 +79,15 @@ export async function createApplication({ storageDomain, providers = [tushare, t
       registry.validate(instance, route)
       const key = `${instance.id}:${route.capability}:${route.market}`
       if (results.some(r => r.key === key)) continue
+      // 探针耗时就是这一条路由端到端拿数据的真实延迟, 用于把「能不能用」和「快不快」一起回给用户
+      const startedAt = now()
       try {
         const result = await executor.run(instance, route.capability, { market: route.market, instrument: route.instrument }, { probe: true, signal })
-        results.push({ key, providerInstanceId: instance.id, capability: route.capability, market: route.market, status: result.status === 'ready' ? 'ready' : 'unavailable' })
-      } catch (e) { results.push({ key, providerInstanceId: instance.id, capability: route.capability, market: route.market, status: 'denied', error: { code: e.code, message: e.message } }) }
+        const status = result.status === 'ready' ? 'ready' : 'unavailable'
+        probeCache.set(key, { status, until: now() + WINDOW })
+        while (probeCache.size > PROBE_LIMIT) probeCache.delete(probeCache.keys().next().value)
+        results.push({ key, providerInstanceId: instance.id, capability: route.capability, market: route.market, status, ms: now() - startedAt })
+      } catch (e) { results.push({ key, providerInstanceId: instance.id, capability: route.capability, market: route.market, status: 'denied', ms: now() - startedAt, error: { code: e.code, message: e.message } }) }
     }
     const checkId = randomUUID()
     checks.set(checkId, { hash: digest(config), until: now() + WINDOW, results })
@@ -85,11 +99,10 @@ export async function createApplication({ storageDomain, providers = [tushare, t
     const config = parseConfiguration(operation.payload)
     const replay = state.replay({ ...operation, action: 'configuration', payload: config })
     if (replay) return replay
-    const hash = digest(config), valid = (operation.checkIds || []).map(id => checks.get(id)).filter(c => c?.until > now() && c.hash === hash)
-    if (config.providers.some(p => p.enabled) && !valid.length) fail('CHECK_REQUIRED', '配置已变化，请重新检查来源能力', 422)
-    for (const route of config.routes) for (const target of [route.primaryInstanceId, ...route.fallbackInstanceIds]) {
-      const instance = config.providers.find(p => p.id === target); registry.validate(instance, route)
-      if (!valid.some(c => c.results.some(r => r.providerInstanceId === target && r.capability === route.capability && r.market === route.market && r.status === 'ready'))) fail('CHECK_REQUIRED', '请先检查所有路由目标能力', 422)
+    // 保存不做连通性闸门: 探针是给人看的诊断信息, 不该把人挡在门外。契约只校验路由自身的合法性,
+    // 按能力挑源已经由前端按适配器能力过滤, 后端再校验一次目标是否具备该能力即可。
+    for (const route of config.routes) {
+      for (const target of [route.primaryInstanceId, ...route.fallbackInstanceIds]) registry.validate(config.providers.find(p => p.id === target), route)
     }
     const result = await state.mutate({ ...operation, action: 'configuration', payload: config }, current => {
       if (JSON.stringify(current.providers) === JSON.stringify(config.providers) && JSON.stringify(current.routes) === JSON.stringify(config.routes)) return current
@@ -134,7 +147,10 @@ export async function createApplication({ storageDomain, providers = [tushare, t
       if (phase === 'remote') {
         for (const item of items) {
           const row = item.raw && typeof item.raw === 'object' ? item.raw : null
-          if (row?.MktNum && /^10[567]$/.test(row.MktNum)) usSymbols.set(`US:${row.Code}`, { mktNum: row.MktNum, jys: row.JYS || null, at: now() })
+          if (row?.MktNum && /^10[567]$/.test(row.MktNum)) {
+            usSymbols.set(`US:${row.Code}`, { mktNum: row.MktNum, jys: row.JYS || null, at: now() })
+            while (usSymbols.size > US_SYMBOL_LIMIT) usSymbols.delete(usSymbols.keys().next().value)
+          }
         }
       }
       for (const [key, value] of usSymbols) if (now() - value.at > US_SYMBOL_TTL) usSymbols.delete(key)
@@ -144,15 +160,18 @@ export async function createApplication({ storageDomain, providers = [tushare, t
       assertLive()
       const parsed = klineQuerySchema.safeParse(input)
       if (!parsed.success) fail('INVALID_PARAM', 'K线请求参数无效', 400)
-      const { securityId: sid, period, limit } = parsed.data
+      const { securityId: sid, period, limit, force } = parsed.data
       let exchange, code
       try { ({ exchange, code } = parseSecurityId(sid)) } catch { fail('INVALID_PARAM', '证券身份无效', 400) }
       const config = state.get()
       const { route, instance } = router.select('kline', exchange, 'equity')
       const fallbacks = route.fallbackInstanceIds.map(id => config.providers.find(p => p.id === id && p.enabled !== false)).filter(Boolean)
-      for (const cand of [instance, ...fallbacks]) {
-        const cached = await klineCache.get({ providerInstanceId: cand.id, market: exchange, period, code }, config.routingRevision)
-        if (cached) return { ...cached.payload, source: cand.id, revision: config.revision }
+      // force=1 跳过缓存读(详情页手动刷新);缓存写入仍按正常策略,失败回源不额外惩罚
+      if (force !== '1') {
+        for (const cand of [instance, ...fallbacks]) {
+          const cached = await klineCache.get({ providerInstanceId: cand.id, market: exchange, period, code }, config.routingRevision)
+          if (cached) return { ...cached.payload, source: cand.id, revision: config.revision }
+        }
       }
       const result = await runWithFailover(route, instance, fallbacks, { securityId: sid, market: exchange, code, period, adjust: 'qfq', limit }, signal)
       if (period !== 'trend') await klineCache.put({ providerInstanceId: result.providerInstanceId, market: exchange, period, code }, result, config.routingRevision)
@@ -171,7 +190,7 @@ export async function createApplication({ storageDomain, providers = [tushare, t
         if (route.instance) {
           const result = await executor.run(route.instance, 'quotes', { securities: [{ id: index.id, exchange: index.exchange, code: index.code }], routingRevision: state.get().routingRevision }, { signal: AbortSignal.timeout(5 * 1000) })
           const quote = result.items?.find(q => q.securityId === index.id)
-          if (quote && quote.last !== null) { deriveDelay(quote, now); overview = { name: index.name, last: quote.last, change: quote.change, changePct: quote.changePct, quoteAt: quote.quoteAt, delayKind: quote.delayKind, delaySeconds: quote.delaySeconds, source: quote.providerInstanceId } }
+          if (quote && quote.last !== null) { deriveDelay(quote, now, quote.sessionState === 'trading'); overview = { name: index.name, last: quote.last, change: quote.change, changePct: quote.changePct, quoteAt: quote.quoteAt, delayKind: quote.delayKind, delaySeconds: quote.delaySeconds, source: quote.providerInstanceId } }
         }
       } catch {}
       return { ...await catalog.browse(input), overview, catalogs: catalog.status(), routingRevision: state.get().routingRevision }

package/src/catalog.mjs

@@ -1,6 +1,17 @@
 import { securitySchema } from './schemas.mjs'
-import { fail } from './market-model.mjs'
+import { fail, sessionStateOf } from './market-model.mjs'
 const DAY = 24 * 60 * 60 * 1000
+const SEARCH_TTL = 60 * 1000
+const SEARCH_CACHE_LIMIT = 64
+const SEARCH_FLIGHT_LIMIT = 32
+const CANDIDATE_TTL = 5 * 60 * 1000
+const CANDIDATE_LIMIT = 200
+// 有界写入: Map 迭代序即插入序, 超限淘汰最早条目, 保证长跑内存不随查询次数增长
+export function setBounded(map, key, value, limit) {
+  map.set(key, value)
+  while (map.size > limit) map.delete(map.keys().next().value)
+  return map
+}
 const localDate = ms => new Date(ms + 8 * 60 * 60 * 1000).toISOString().slice(0, 10)
 // 实例id→其适配器 markets 集合(搜索市场面唯一事实源)
 function adapterMarketsOf(config, registry) {
@@ -13,7 +24,7 @@ function adapterMarketsOf(config, registry) {
 }
 
 export function createCatalog({ state, getControl = state.get, router, executor, registry, now = Date.now, changed = () => {} }) {
-  const flights = new Map(), candidates = new Map()
+  const flights = new Map(), candidates = new Map(), searchCache = new Map(), searchFlights = new Map()
   let stopped = false
   const controllers = new Set()
   function records(kind) {
@@ -32,7 +43,8 @@ export function createCatalog({ state, getControl = state.get, router, executor,
   function search(q, limit = 20) {
     const query = q.trim().toLowerCase()
     if (!query) return []
-    const score = s => s.code === query ? 0 : s.officialName.toLowerCase() === query ? 1 : s.code.startsWith(query) ? 2 : s.officialName.toLowerCase().includes(query) ? 3 : s.cnspell?.toLowerCase().startsWith(query) ? 4 : 99
+    // 代码大小写不敏感: 美股代码全大写, 逐字比较会让本地目录搜不到 aapl/apple
+    const score = s => { const code = s.code.toLowerCase(), name = s.officialName.toLowerCase(); return code === query ? 0 : name === query ? 1 : code.startsWith(query) ? 2 : name.includes(query) ? 3 : s.cnspell?.toLowerCase().startsWith(query) ? 4 : 99 }
     return all().map(s => ({ s, rank: score(s) })).filter(r => r.rank < 99).sort((a, b) => a.rank - b.rank || a.s.id.localeCompare(b.s.id)).slice(0, limit).map(r => r.s)
   }
   return {
@@ -55,37 +67,53 @@ export function createCatalog({ state, getControl = state.get, router, executor,
     },
     status: () => records('catalog').map(c => ({ source: c.source, fetchedAt: c.fetchedAt, complete: c.payload.complete, stale: now() - c.fetchedAt > (c.kind === 'calendar' ? 7 * DAY : DAY) })),
     async remote(q, signal) {
-      const config = structuredClone(getControl()), results = new Map(search(q).map(s => [s.id, s]))
-      // 搜索市场面=启用实例的适配器市场并集(suggest 天然全市场, 已启用市场语义跟随实例能力而非路由)
-      const adapterMarkets = adapterMarketsOf(config, registry)
-      const quoteMarkets = new Set([...adapterMarkets.values()].flatMap(set => [...set]))
-      const searchRoutes = new Map(config.routes.filter(r => r.capability === 'search').map(r => [r.market, r]))
-      for (const market of quoteMarkets) {
-        const route = searchRoutes.get(market)
-        let instance
-        if (route) { instance = router.select('search', market).instance }
-        else {
-          // 无 search 路由的市场: 用支持 search 的启用实例直连(市场过滤在适配器端)
-          const searchAdapters = new Set((registry?.descriptors() || []).filter(d => d.capabilities.includes('search')).map(d => d.adapterId))
-          instance = config.providers.find(p => p.enabled && searchAdapters.has(p.adapterId) && adapterMarkets.get(p.id)?.has(market))
-            || config.providers.find(p => p.enabled && searchAdapters.has(p.adapterId))
+      const config = structuredClone(getControl()), revision = config.routingRevision, key = `${revision}:${q.trim().toLowerCase()}`
+      // 结果缓存与在途合并: 联想接口按查询词去重, 退格重输同一词零远端开销
+      const cached = searchCache.get(key)
+      if (cached && cached.until > now()) return cached.items
+      const inflight = searchFlights.get(key)
+      if (inflight && !inflight.signal?.aborted) return inflight.job
+      const job = (async () => {
+        const results = new Map(search(q).map(s => [s.id, s]))
+        // 搜索市场面=启用实例的适配器市场并集(suggest 天然全市场, 已启用市场语义跟随实例能力而非路由)
+        const adapterMarkets = adapterMarketsOf(config, registry)
+        const searchAdapters = new Set((registry?.descriptors() || []).filter(d => d.capabilities.includes('search')).map(d => d.adapterId))
+        const searchRoutes = new Map(config.routes.filter(r => r.capability === 'search').map(r => [r.market, r]))
+        // 实例→负责市场: 有 search 路由用路由实例, 无路由用支持 search 的启用实例直连(市场过滤在适配器端)
+        const assignments = new Map()
+        for (const market of new Set([...adapterMarkets.values()].flatMap(set => [...set]))) {
+          const instance = searchRoutes.has(market) ? router.select('search', market).instance
+            : config.providers.find(p => p.enabled && searchAdapters.has(p.adapterId) && adapterMarkets.get(p.id)?.has(market))
+              || config.providers.find(p => p.enabled && searchAdapters.has(p.adapterId))
           if (!instance) continue
+          const entry = assignments.get(instance.id) || { instance, markets: new Set() }
+          entry.markets.add(market); assignments.set(instance.id, entry)
         }
-        // 单市场来源限速不终止整个搜索:其余市场候选照常下发(逐市场直连,部分受限不影响其余)
-        let batch
-        try { batch = await executor.run(instance, 'search', { q, limit: 20, market, routingRevision: config.routingRevision }, { signal }) }
-        catch (e) { if (e.code === 'RATE_LIMIT') continue; throw e }
-        if (stopped || getControl().routingRevision !== config.routingRevision) fail('ROUTE_CONFLICT', '目录路由已变化', 409)
-        for (const s of batch.items) {
-          if (!securitySchema.safeParse(s).success) fail('BAD_PAYLOAD', '来源返回不受支持的证券身份', 502)
-          candidates.set(s.id, { security: s, until: now() + 5 * 60 * 1000, revision: config.routingRevision }); results.set(s.id, s)
+        // 一个实例只请求一次: 联想端点为全市场端点, 按市场循环是重复请求同一份数据
+        const batches = await Promise.allSettled([...assignments.values()].map(async ({ instance, markets }) => ({ markets, batch: await executor.run(instance, 'search', { q, limit: 20, market: null, routingRevision: revision }, { signal }) })))
+        for (const settled of batches) {
+          // 单来源限速不终止整个搜索: 其余实例候选照常下发
+          if (settled.status === 'rejected') { if (settled.reason?.code === 'RATE_LIMIT') continue; throw settled.reason }
+          const { markets, batch } = settled.value
+          if (stopped || getControl().routingRevision !== revision) fail('ROUTE_CONFLICT', '目录路由已变化', 409)
+          for (const s of batch.items) {
+            if (!securitySchema.safeParse(s).success) fail('BAD_PAYLOAD', '来源返回不受支持的证券身份', 502)
+            if (!markets.has(s.exchange)) continue
+            candidates.set(s.id, { security: s, until: now() + CANDIDATE_TTL, revision }); results.set(s.id, s)
+          }
         }
-      }
-      for (const [id, c] of candidates) if (c.until <= now()) candidates.delete(id)
-      while (candidates.size > 200) candidates.delete(candidates.keys().next().value)
-      if (!config.routes.some(r => r.capability === 'search') && !records('catalog').length) fail('CATALOG_NOT_READY', '目录未就绪，请先在设置中配置目录来源或搜索来源并同步', 422)
-      return [...results.values()].slice(0, 20)
+        for (const [id, c] of candidates) if (c.until <= now()) candidates.delete(id)
+        while (candidates.size > CANDIDATE_LIMIT) candidates.delete(candidates.keys().next().value)
+        if (!config.routes.some(r => r.capability === 'search') && !records('catalog').length) fail('CATALOG_NOT_READY', '目录未就绪，请先在设置中配置目录来源或搜索来源并同步', 422)
+        const items = [...results.values()].slice(0, 20)
+        setBounded(searchCache, key, { items, until: now() + SEARCH_TTL }, SEARCH_CACHE_LIMIT)
+        return items
+      })()
+      setBounded(searchFlights, key, { job, signal }, SEARCH_FLIGHT_LIMIT)
+      try { return await job } finally { if (searchFlights.get(key)?.job === job) searchFlights.delete(key) }
     },
+    // 内存占用可观测: 长跑核对缓存不越界
+    stats: () => ({ searchCache: searchCache.size, candidates: candidates.size, searchFlights: searchFlights.size, syncFlights: flights.size }),
     async ensure() {
       for (const route of getControl().routes.filter(r => ['catalog', 'calendar'].includes(r.capability))) {
         if (getControl().providers.find(p => p.id === route.primaryInstanceId)?.budget.requestsPerMinute === null) continue
@@ -122,7 +150,8 @@ export function createCatalog({ state, getControl = state.get, router, executor,
     },
     marketState(market) {
       const date = localDate(now()), day = records('calendar').filter(c => c.payload.market === market).flatMap(c => c.payload.items).find(d => d.date === date)
-      if (!day || typeof day.isOpen !== 'boolean') return { state: 'unknown' }
+      // 没同步过日历就按市场自身的时段判断, 别让八市场统一显示「未知」; 有日历数据时以日历(含节假日)为准
+      if (!day || typeof day.isOpen !== 'boolean') return { state: sessionStateOf(market, now()) }
       const local = new Date(now() + 8 * 60 * 60 * 1000), minutes = local.getUTCHours() * 60 + local.getUTCMinutes()
       const at = minute => Date.parse(`${date}T00:00:00+08:00`) + minute * 60 * 1000
       if (!day.isOpen) return { state: 'closed', nextAt: at(24 * 60 + 9 * 60 + 15) }