@363045841yyt/klinechart-core 0.9.0-alpha.3 → 0.9.0-alpha.4

package/src/engine/chart.ts

@@ -151,7 +151,13 @@ export class Chart {
     zoomLevel: number
     scaleTypes: Map<string, ScaleType>
     mainIndicators: Array<{ id: string; params: Record<string, number | boolean | string> }>
-    subPanes: Array<{ id: string; params: Record<string, unknown> }>
+    subPanes: Array<{
+      paneId: string
+      indicatorId: string
+      params: Record<string, unknown>
+    }>
+    paneRatios: Record<string, number>
+    candleEnabled: boolean
   } | null = null
 
   /** 上次预警评估的最新 K 线时间戳（用于去重） */
@@ -470,17 +476,21 @@ export class Chart {
     const prev = this._activeMode
 
     if (mode === this._timeShareMode) {
+      const candlePlugin = this.rendererPluginManager.getPlugin('candle')
       this._savedTimeShareState = {
         zoomLevel: this.kernel.zoom.readonly.zoomLevel.peek(),
         scaleTypes: new Map(this.kernel.pane.readonly.paneScaleTypes.peek()),
         mainIndicators: [],
         subPanes: [],
+        paneRatios: { ...this.kernel.pane.readonly.paneRatios.peek() },
+        candleEnabled: candlePlugin?.enabled !== false,
       }
       for (const [id, entry] of this.kernel.indicator.readonly.mainIndicators.peek()) {
         this._savedTimeShareState.mainIndicators.push({ id, params: { ...entry.params } })
       }
       this._savedTimeShareState.subPanes = this.indicatorManager.getSubPaneEntries().map((e) => ({
-        id: e.indicatorId,
+        paneId: e.paneId,
+        indicatorId: e.indicatorId,
         params: { ...e.params },
       }))
       // 分时强制 percent 进 kernel，再投影（不再由 updatePaneRange 每帧旁路写）
@@ -526,7 +536,7 @@ export class Chart {
 
     if (mode === this._timeShareMode) {
       for (const { id } of this._savedTimeShareState!.mainIndicators) {
-        if (id !== 'TIMESHARE') {
+        if (id !== 'TIMESHARE' && id !== 'timeShare') {
           this.indicatorManager.disableMainIndicator(id)
         }
       }
@@ -535,13 +545,26 @@ export class Chart {
       const saved = this._savedTimeShareState
       if (saved) {
         for (const { id, params } of saved.mainIndicators) {
-          if (id !== 'TIMESHARE') {
+          if (id !== 'TIMESHARE' && id !== 'timeShare') {
             this.indicatorManager.enableMainIndicator(id, params)
           }
         }
-        for (const { id, params } of saved.subPanes) {
-          this.indicatorManager.addIndicator(id, 'sub', params)
+        for (const { paneId, indicatorId, params } of saved.subPanes) {
+          this.indicatorManager.createSubPane(
+            paneId,
+            indicatorId as SubIndicatorType,
+            params as Record<string, number | boolean | string>,
+          )
         }
+        // 恢复进入分时前的 pane 比例（createSubPane 会重算 3:1 分配）
+        if (Object.keys(saved.paneRatios).length > 0) {
+          const specs = this.kernel.pane.readonly.paneSpecs.peek().map((pane) => ({
+            ...pane,
+            ratio: saved.paneRatios[pane.id] ?? pane.ratio,
+          }))
+          this.kernel.pane.actions.commitLayout(saved.paneRatios, specs)
+        }
+        this.setRendererEnabled('candle', saved.candleEnabled)
       }
       this._savedTimeShareState = null
     }

package/src/engine/data/chartDataManager.ts

@@ -452,6 +452,16 @@ export class ChartDataManager {
     return buf ? buf.getRawData() : []
   }
 
+  getTimeSharePreClose(): number | null {
+    const buf = this.getActiveTimeShareBuffer()
+    return buf?.getPreClose() ?? null
+  }
+
+  setTimeSharePreClose(preClose: number | null): void {
+    const buf = this.getActiveTimeShareBuffer()
+    if (buf) buf.setPreClose(preClose)
+  }
+
   getTimeShareSignal(): ReadonlySignal<ReadonlyArray<TimeShareData>> {
     const buf = this.getActiveTimeShareBuffer()
     return (buf?.data ?? createSignal<ReadonlyArray<TimeShareData>>([])) as ReadonlySignal<

package/src/engine/modes/__tests__/timeShareMath.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  resolveTimeShareSlotTimestamp,
+  timeShareSlotCenterX,
+} from '../../../foundation/utils/timeShareAxisLabels'
+import {
+  ASHARE_TIMESHARE_SESSION_SLOTS,
+  computeTimeShareBarMetrics,
+  computeTimeSharePaneLayout,
+  computeTimeSharePriceRange,
+  computeTimeShareTimeLabelIndices,
+  computeTimeShareXLayout,
+  resolveTimeShareSessionSlots,
+  resolveTimeShareBaseline,
+} from '../timeShareMath'
+
+describe('resolveTimeShareBaseline', () => {
+  it('prefers finite non-zero preClose over first trade price', () => {
+    expect(resolveTimeShareBaseline({ preClose: 10.5, firstPrice: 11 })).toBe(10.5)
+  })
+
+  it('falls back to first price when preClose is missing or zero', () => {
+    expect(resolveTimeShareBaseline({ preClose: 0, firstPrice: 11 })).toBe(11)
+    expect(resolveTimeShareBaseline({ firstPrice: 11 })).toBe(11)
+    expect(resolveTimeShareBaseline({ preClose: null, firstPrice: 9 })).toBe(9)
+  })
+
+  it('returns null when no valid baseline exists', () => {
+    expect(resolveTimeShareBaseline({ preClose: 0, firstPrice: 0 })).toBeNull()
+    expect(resolveTimeShareBaseline({})).toBeNull()
+    expect(resolveTimeShareBaseline({ preClose: NaN, firstPrice: Infinity })).toBeNull()
+  })
+})
+
+describe('computeTimeSharePriceRange', () => {
+  it('uses preClose baseline and pads around max absolute percent move', () => {
+    // open gap up: first trade 11, preClose 10 → +10%; later 10.5 → 5%
+    const range = computeTimeSharePriceRange([11, 10.5, 10.2], 10)
+    expect(range).not.toBeNull()
+    // maxAbsPct=10, padding=max(1, 0.5)=1 → display 11%
+    expect(range!.maxPrice).toBeCloseTo(10 * 1.11, 8)
+    expect(range!.minPrice).toBeCloseTo(10 * 0.89, 8)
+  })
+
+  it('still applies minimum padding when all prices equal baseline (flat day)', () => {
+    const range = computeTimeSharePriceRange([10, 10, 10], 10)
+    expect(range).not.toBeNull()
+    // maxAbsPct=0, padding=min 0.5% → ±0.5%
+    expect(range!.maxPrice).toBeCloseTo(10.05, 8)
+    expect(range!.minPrice).toBeCloseTo(9.95, 8)
+  })
+
+  it('returns null for invalid baseline', () => {
+    expect(computeTimeSharePriceRange([10], 0)).toBeNull()
+    expect(computeTimeSharePriceRange([10], NaN)).toBeNull()
+  })
+})
+
+describe('resolveTimeShareSessionSlots', () => {
+  it('defaults to A-share 240 one-minute slots (sessions SSOT)', () => {
+    expect(ASHARE_TIMESHARE_SESSION_SLOTS).toBe(240)
+    expect(resolveTimeShareSessionSlots(0)).toBe(240)
+    expect(resolveTimeShareSessionSlots(60)).toBe(240)
+  })
+
+  it('does not expand when arrived points exceed session slots', () => {
+    expect(resolveTimeShareSessionSlots(300)).toBe(240)
+  })
+})
+
+describe('computeTimeShareBarMetrics', () => {
+  it('divides viewWidth by full session slots, not arrived point count', () => {
+    // 盘中仅 60 点：宽度仍按 240 槽划分，不把 60 点拉满屏
+    const partial = computeTimeShareBarMetrics(60, 320, 1)
+    const full = computeTimeShareBarMetrics(240, 320, 1)
+    expect(partial).not.toBeNull()
+    expect(full).not.toBeNull()
+    expect(partial!.kWidth).toBeCloseTo(full!.kWidth, 8)
+    expect(partial!.kGap).toBeCloseTo(full!.kGap, 8)
+    expect((partial!.kWidth + partial!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('fits full session into viewWidth even when per-bar width is sub-pixel (DPR=1 narrow)', () => {
+    const m = computeTimeShareBarMetrics(240, 320, 1)
+    expect(m).not.toBeNull()
+    const unit = m!.kWidth + m!.kGap
+    expect(unit * 240).toBeCloseTo(320, 6)
+    expect(m!.kWidth).toBeGreaterThan(0)
+    expect(m!.kGap).toBeGreaterThanOrEqual(0)
+  })
+
+  it('keeps full session visible at high DPR', () => {
+    const m = computeTimeShareBarMetrics(240, 320, 2)
+    expect(m).not.toBeNull()
+    expect((m!.kWidth + m!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('returns null for empty data or invalid width', () => {
+    expect(computeTimeShareBarMetrics(0, 320, 1)).toBeNull()
+    expect(computeTimeShareBarMetrics(10, 0, 1)).toBeNull()
+  })
+})
+
+describe('computeTimeShareXLayout', () => {
+  it('places partial-day points on session timeline leaving right-side blank', () => {
+    const layout = computeTimeShareXLayout({
+      arrivedCount: 60,
+      sessionSlots: 240,
+      totalWidth: 480,
+      dpr: 1,
+    })
+    expect(layout).not.toBeNull()
+    // step = 480/240 = 2；第 0 点中心 1，第 59 点中心 119，未到右缘 480
+    expect(layout!.centers[0]).toBeCloseTo(1, 6)
+    expect(layout!.centers[59]).toBeCloseTo(119, 6)
+    expect(layout!.centers[59]!).toBeLessThan(480 * 0.3)
+    expect(layout!.step).toBeCloseTo(2, 6)
+  })
+
+  it('fills full width only when arrivedCount covers full session', () => {
+    const layout = computeTimeShareXLayout({
+      arrivedCount: 240,
+      sessionSlots: 240,
+      totalWidth: 480,
+      dpr: 1,
+    })
+    expect(layout).not.toBeNull()
+    expect(layout!.centers[0]).toBeCloseTo(1, 6)
+    expect(layout!.centers[239]).toBeCloseTo(479, 6)
+  })
+})
+
+describe('computeTimeSharePaneLayout', () => {
+  it('splits price area above volume area without overlap', () => {
+    const layout = computeTimeSharePaneLayout(400, 0.25)
+    expect(layout.priceAreaHeight).toBe(300)
+    expect(layout.volumeAreaHeight).toBe(100)
+    expect(layout.priceTop).toBe(0)
+    expect(layout.volumeTop).toBe(300)
+    expect(layout.priceTop + layout.priceAreaHeight).toBe(layout.volumeTop)
+  })
+})
+
+describe('computeTimeShareTimeLabelIndices', () => {
+  it('only session closed-side endpoints: 9:30 / 13:00 / 15:00', () => {
+    const labels = computeTimeShareTimeLabelIndices({
+      axisWidth: 800,
+      sessionSlots: 240,
+    })
+    // 9:30 → 0；13:00 → 120；15:00 → 239
+    expect(labels).toEqual([0, 120, 239])
+  })
+
+  it('returns empty for invalid axis width', () => {
+    expect(
+      computeTimeShareTimeLabelIndices({
+        axisWidth: 0,
+        sessionSlots: 240,
+      }),
+    ).toEqual([])
+  })
+})
+
+describe('timeShare slot time/x helpers', () => {
+  it('maps A-share slots across lunch break', () => {
+    // 2026-07-21 local
+    const day = new Date(2026, 6, 21, 10, 0, 0, 0).getTime()
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 0)).getHours()).toBe(9)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 0)).getMinutes()).toBe(30)
+    // slot 120 = 13:00
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 120)).getHours()).toBe(13)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 120)).getMinutes()).toBe(0)
+    // slot 239 = 14:59
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 239)).getHours()).toBe(14)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 239)).getMinutes()).toBe(59)
+  })
+
+  it('places last session slot near right edge of axis', () => {
+    const x0 = timeShareSlotCenterX(0, 480, 240, 1)
+    const xLast = timeShareSlotCenterX(239, 480, 240, 1)
+    expect(x0).toBeCloseTo(1, 6)
+    expect(xLast).toBeCloseTo(479, 6)
+  })
+})

package/src/engine/modes/__tests__/timeShareMode.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { Pane } from '../../layout/pane'
+import { TimeShareMode } from '../timeShareMode'
+import type { TimeShareData } from '../../../foundation/types/price'
+
+function ts(price: number, i = 0): TimeShareData {
+  return { timestamp: i, price, average: price, volume: 1, amount: price }
+}
+
+function mockDm(points: TimeShareData[], preClose: number | null = null) {
+  return {
+    getTimeShareData: () => points,
+    getTimeSharePreClose: () => preClose,
+  } as unknown as import('../../data/chartDataManager').ChartDataManager
+}
+
+describe('TimeShareMode', () => {
+  it('computeKWidth fits full session into narrow view (no DPR truncation)', () => {
+    const mode = new TimeShareMode()
+    const m = mode.computeKWidth(240, 320, 1)
+    expect(m).not.toBeNull()
+    expect((m!.kWidth + m!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('computeKWidth for partial day matches full-session bar size', () => {
+    const mode = new TimeShareMode()
+    const partial = mode.computeKWidth(60, 320, 1)
+    const full = mode.computeKWidth(240, 320, 1)
+    expect(partial).not.toBeNull()
+    expect(full).not.toBeNull()
+    expect(partial!.kWidth).toBeCloseTo(full!.kWidth, 8)
+    expect(partial!.kGap).toBeCloseTo(full!.kGap, 8)
+  })
+
+  it('setMarketSession switches bar metrics to HK 330 slots', () => {
+    const mode = new TimeShareMode()
+    const ashare = mode.computeKWidth(100, 330, 1)!
+    mode.setMarketSession({
+      timeZone: 'Asia/Hong_Kong',
+      sessions: [
+        { open: 9 * 60 + 30, close: 12 * 60 },
+        { open: 13 * 60, close: 16 * 60 },
+      ],
+      slotMinutes: 1,
+    })
+    const hk = mode.computeKWidth(100, 330, 1)!
+    // A 股 240 槽 unit=330/240；港股 330 槽 unit=1
+    expect(ashare.kWidth + ashare.kGap).toBeCloseTo(330 / 240, 6)
+    expect(hk.kWidth + hk.kGap).toBeCloseTo(1, 6)
+  })
+
+  it('updatePaneRange uses preClose as basePrice and covers open gap', () => {
+    const mode = new TimeShareMode()
+    const pane = new Pane('main')
+    const setBase = vi.spyOn(pane.yAxis, 'setBasePrice')
+    const setRange = vi.spyOn(pane.yAxis, 'setRange')
+
+    // open gap: first trade 11, preClose 10
+    mode.updatePaneRange(pane, { start: 0, end: 3 }, mockDm([ts(11), ts(10.5), ts(10.2)], 10))
+
+    expect(setBase).toHaveBeenCalledWith(10)
+    expect(setRange).toHaveBeenCalled()
+    const range = setRange.mock.calls[0]![0] as { minPrice: number; maxPrice: number }
+    // maxAbs 10% + 1% padding → ±11%
+    expect(range.maxPrice).toBeCloseTo(11.1, 6)
+    expect(range.minPrice).toBeCloseTo(8.9, 6)
+  })
+
+  it('updatePaneRange still sets range on flat day', () => {
+    const mode = new TimeShareMode()
+    const pane = new Pane('main')
+    const setRange = vi.spyOn(pane.yAxis, 'setRange')
+
+    mode.updatePaneRange(pane, { start: 0, end: 2 }, mockDm([ts(10), ts(10)], 10))
+    expect(setRange).toHaveBeenCalled()
+    const range = setRange.mock.calls[0]![0] as { minPrice: number; maxPrice: number }
+    expect(range.maxPrice).toBeCloseTo(10.05, 6)
+    expect(range.minPrice).toBeCloseTo(9.95, 6)
+  })
+})

package/src/engine/modes/timeShareMath.ts

@@ -0,0 +1,150 @@
+import {
+  ASHARE_MARKET_SESSION,
+  resolveMarketSessionSlots,
+  type MarketSessionConfig,
+} from '../../foundation/utils/timeShareAxisLabels'
+
+export type TimeShareBaselineInput = {
+  preClose?: number | null
+  firstPrice?: number | null
+}
+
+export function resolveTimeShareBaseline(input: TimeShareBaselineInput): number | null {
+  const candidates = [input.preClose, input.firstPrice]
+  for (const v of candidates) {
+    if (typeof v === 'number' && Number.isFinite(v) && v !== 0) return v
+  }
+  return null
+}
+
+export type TimeSharePriceRange = {
+  minPrice: number
+  maxPrice: number
+}
+
+/**
+ * 分时 Y 轴价格区间：以 baseline（昨收）为中心，对称覆盖可见最大绝对涨跌幅并加 padding。
+ * 全天平盘时仍保留最小 0.5% 边距，避免 range 退化。
+ */
+export function computeTimeSharePriceRange(
+  prices: ReadonlyArray<number | undefined | null>,
+  baseline: number,
+): TimeSharePriceRange | null {
+  if (!Number.isFinite(baseline) || baseline === 0) return null
+
+  let maxAbsPct = 0
+  for (const p of prices) {
+    if (typeof p !== 'number' || !Number.isFinite(p)) continue
+    const pct = Math.abs((p - baseline) / baseline) * 100
+    if (pct > maxAbsPct) maxAbsPct = pct
+  }
+
+  const padding = Math.max(maxAbsPct * 0.1, 0.5)
+  const displayPct = maxAbsPct + padding
+  return {
+    minPrice: baseline * (1 - displayPct / 100),
+    maxPrice: baseline * (1 + displayPct / 100),
+  }
+}
+
+/** A 股默认全天 1 分钟槽位数（兼容旧导出） */
+export const ASHARE_TIMESHARE_SESSION_SLOTS = resolveMarketSessionSlots(ASHARE_MARKET_SESSION)
+
+/**
+ * 全天交易槽位数：以 marketSession 为 SSOT，不因 arrivedCount 放大。
+ * @deprecated 优先用 resolveMarketSessionSlots(config)
+ */
+export function resolveTimeShareSessionSlots(
+  arrivedCount: number,
+  marketSession: MarketSessionConfig = ASHARE_MARKET_SESSION,
+): number {
+  void arrivedCount
+  return resolveMarketSessionSlots(marketSession)
+}
+
+/**
+ * 分时 bar 宽度：按全天 sessionSlots 均分 viewWidth，而非按已到达点数。
+ * 盘中部分数据时右侧留白；允许亚像素，避免窄屏截断。
+ */
+export function computeTimeShareBarMetrics(
+  dataLength: number,
+  viewWidth: number,
+  dpr: number,
+  marketSession: MarketSessionConfig = ASHARE_MARKET_SESSION,
+): { kWidth: number; kGap: number } | null {
+  if (dataLength <= 0 || viewWidth <= 0 || !(dpr > 0)) return null
+
+  const sessionSlots = resolveMarketSessionSlots(marketSession)
+  if (sessionSlots <= 0) return null
+  const unit = viewWidth / sessionSlots
+  const preferredGap = 1 / dpr
+  const kGap = Math.min(preferredGap, unit * 0.2)
+  const kWidth = Math.max(unit - kGap, unit * 0.01)
+  return { kWidth, kGap: unit - kWidth }
+}
+
+export type TimeShareXLayoutInput = {
+  arrivedCount: number
+  sessionSlots: number
+  totalWidth: number
+  dpr: number
+}
+
+export type TimeShareXLayout = {
+  step: number
+  centers: number[]
+  lefts: number[]
+  barWidth: number
+  kWidthPx: number
+}
+
+/**
+ * 分时 X 布局：step = totalWidth / sessionSlots，已到达点按 slot 索引落位，未到时段留白。
+ */
+export function computeTimeShareXLayout(input: TimeShareXLayoutInput): TimeShareXLayout | null {
+  const { arrivedCount, sessionSlots, totalWidth, dpr } = input
+  if (arrivedCount <= 0 || sessionSlots <= 0 || totalWidth <= 0 || !(dpr > 0)) return null
+
+  const step = totalWidth / sessionSlots
+  const centers: number[] = new Array(arrivedCount)
+  const lefts: number[] = new Array(arrivedCount)
+  for (let i = 0; i < arrivedCount; i++) {
+    centers[i] = Math.round((i + 0.5) * step * dpr) / dpr
+    lefts[i] = Math.round(i * step * dpr) / dpr
+  }
+
+  const logicalBarWidth = Math.max(step * 0.6, 1 / dpr)
+  const barWidthPx = Math.max(1, Math.round(logicalBarWidth * dpr))
+  const barWidth = barWidthPx / dpr
+  const kWidthPx = Math.max(1, Math.round(step * dpr))
+
+  return { step, centers, lefts, barWidth, kWidthPx }
+}
+
+export type TimeSharePaneLayout = {
+  priceTop: number
+  priceAreaHeight: number
+  volumeTop: number
+  volumeAreaHeight: number
+}
+
+export function computeTimeSharePaneLayout(
+  paneHeight: number,
+  volumeRatio: number,
+): TimeSharePaneLayout {
+  const ratio = Math.min(1, Math.max(0, volumeRatio))
+  const volumeAreaHeight = paneHeight * ratio
+  const priceAreaHeight = paneHeight - volumeAreaHeight
+  return {
+    priceTop: 0,
+    priceAreaHeight,
+    volumeTop: priceAreaHeight,
+    volumeAreaHeight,
+  }
+}
+
+export {
+  TIMESHARE_MIN_LABEL_SPACING_PX,
+  computeTimeShareTimeLabelIndices,
+  type TimeShareTimeLabelInput,
+} from '../../foundation/utils/timeShareAxisLabels'

package/src/engine/modes/timeShareMode.ts

@@ -1,6 +1,14 @@
 import type { ChartDataManager } from '../data/chartDataManager'
 import type { Pane, VisibleRange } from '../layout/pane'
 
+import type { MarketSessionConfig } from '../../foundation/utils/timeShareAxisLabels'
+import { ASHARE_MARKET_SESSION } from '../../foundation/utils/timeShareAxisLabels'
+
+import {
+  computeTimeShareBarMetrics,
+  computeTimeSharePriceRange,
+  resolveTimeShareBaseline,
+} from './timeShareMath'
 import type { ChartModeHandler } from './types'
 
 export class TimeShareMode implements ChartModeHandler {
@@ -12,6 +20,17 @@ export class TimeShareMode implements ChartModeHandler {
   readonly allowRightAxisScale = false
   readonly useIndicatorScheduler = false
 
+  /** 市场 session；默认 A 股，可 setMarketSession 切换 */
+  private _marketSession: MarketSessionConfig = ASHARE_MARKET_SESSION
+
+  get marketSession(): MarketSessionConfig {
+    return this._marketSession
+  }
+
+  setMarketSession(config: MarketSessionConfig): void {
+    this._marketSession = config
+  }
+
   computeContentWidth(
     _dataLength: number,
     leftBufferWidth: number,
@@ -27,17 +46,7 @@ export class TimeShareMode implements ChartModeHandler {
     viewWidth: number,
     dpr: number,
   ): { kWidth: number; kGap: number } | null {
-    if (dataLength <= 0 || viewWidth <= 0) return null
-
-    const kGapPx = 1
-    const totalGapPx = (dataLength + 1) * kGapPx
-    const availablePx = Math.max(1, viewWidth * dpr - totalGapPx)
-    const kWidthPx = Math.max(1, Math.floor(availablePx / dataLength))
-
-    return {
-      kWidth: kWidthPx / dpr,
-      kGap: kGapPx / dpr,
-    }
+    return computeTimeShareBarMetrics(dataLength, viewWidth, dpr, this._marketSession)
   }
 
   updatePaneRange(
@@ -47,30 +56,28 @@ export class TimeShareMode implements ChartModeHandler {
     _mergedIndicatorRange?: { min: number; max: number } | null,
   ): void {
     const tsData = dm.getTimeShareData()
-    const end = Math.min(range.end, tsData.length)
     if (tsData.length === 0) return
 
-    const baseline = tsData[0]?.price ?? 0
-    if (baseline === 0) return
+    const end = Math.min(range.end, tsData.length)
+    const start = Math.max(0, range.start)
+    // 优先昨收；缺失时回退首笔价
+    const baseline = resolveTimeShareBaseline({
+      preClose: dm.getTimeSharePreClose(),
+      firstPrice: tsData[0]?.price,
+    })
+    if (baseline === null) return
 
     // scaleType 由 kernel.paneScaleTypes 投影（进入 timeshare 时写 percent）；此处只设会话 basePrice
     pane.yAxis.setBasePrice(baseline)
 
-    let maxAbsPct = 0
-    for (let i = Math.max(0, range.start); i < end; i++) {
+    const prices: number[] = []
+    for (let i = start; i < end; i++) {
       const p = tsData[i]?.price
-      if (p !== undefined && Number.isFinite(p)) {
-        const pct = Math.abs((p - baseline) / baseline) * 100
-        if (pct > maxAbsPct) maxAbsPct = pct
-      }
+      if (p !== undefined) prices.push(p)
     }
-    if (maxAbsPct <= 0) return
-
-    const padding = Math.max(maxAbsPct * 0.1, 0.5)
-    const displayPct = maxAbsPct + padding
-    const minPrice = baseline * (1 - displayPct / 100)
-    const maxPrice = baseline * (1 + displayPct / 100)
-    pane.yAxis.setRange({ maxPrice, minPrice })
+    const priceRange = computeTimeSharePriceRange(prices, baseline)
+    if (!priceRange) return
+    pane.yAxis.setRange(priceRange)
   }
 
   onActivate(
@@ -103,6 +110,6 @@ export class TimeShareMode implements ChartModeHandler {
     _next: ChartModeHandler | null,
   ): void {
     chart.disableMainIndicator('timeShare')
-    chart.setRendererEnabled('candle', true)
+    // candle 可见性由 Chart.setActiveMode 按进入前快照恢复，此处不强制 true
   }
 }

package/src/engine/render/chartRenderer.ts

@@ -31,6 +31,9 @@ import { ChartIndicatorManager } from '../indicators/chartIndicatorManager'
 import { UpdateLevel } from '../layout/pane'
 import type { VisibleRange } from '../layout/pane'
 import { MarkerManager, type CustomMarkerEntity, type MarkerManagerDeps } from '../marker/registry'
+import { ASHARE_MARKET_SESSION } from '../../foundation/utils/timeShareAxisLabels'
+import { resolveMarketSessionSlots } from '../../foundation/utils/timeShareAxisLabels'
+import { computeTimeShareXLayout } from '../modes/timeShareMath'
 import type { ChartModeHandler } from '../modes/types'
 import { PaneRenderer } from '../paneRenderer'
 import { createTimeAxisRendererPlugin } from '../renderers/timeAxis'
@@ -588,29 +591,31 @@ export class ChartRenderer {
         kBarRects[i] = { x: barLeftPx / vp.dpr, width: barWidthPx / vp.dpr }
       }
 
-      // TimeShare 按 plotWidth 平分 bar，覆盖 calcKLinePositions 的结果
+      // TimeShare：按全天 sessionSlots 划分宽度，已到达点落在时间线上，未到时段右侧留白
       if (mode.debugName === 'TimeShare') {
-        const totalWidth = vp.plotWidth
         const count = kLineCenters.length
-        if (count > 0) {
-          const dpr = vp.dpr
-          const step = totalWidth / count
-          for (let i = 0; i < count; i++) {
-            kLineCenters[i] = Math.round((i + 0.5) * step * dpr) / dpr
-            kLinePositions[i] = Math.round(i * step * dpr) / dpr
-          }
-          kWidthPx = Math.round((totalWidth * dpr) / count)
-
-          const logicalBarWidth = Math.max(1, step * 0.6)
-          const barWidthPx = Math.round(logicalBarWidth * dpr)
-          const halfBarPx = Math.floor(barWidthPx / 2)
+        const marketSession =
+          'marketSession' in mode && mode.marketSession
+            ? (mode as { marketSession: typeof ASHARE_MARKET_SESSION }).marketSession
+            : ASHARE_MARKET_SESSION
+        const layout = computeTimeShareXLayout({
+          arrivedCount: count,
+          sessionSlots: resolveMarketSessionSlots(marketSession),
+          totalWidth: vp.plotWidth,
+          dpr: vp.dpr,
+        })
+        if (layout) {
+          const halfBarPx = Math.floor((layout.barWidth * vp.dpr) / 2)
           for (let i = 0; i < count; i++) {
-            const centerPx = Math.round(kLineCenters[i]! * dpr)
+            kLineCenters[i] = layout.centers[i]!
+            kLinePositions[i] = layout.lefts[i]!
+            const centerPx = Math.round(layout.centers[i]! * vp.dpr)
             kBarRects[i] = {
-              x: (centerPx - halfBarPx) / dpr,
-              width: barWidthPx / dpr,
+              x: (centerPx - halfBarPx) / vp.dpr,
+              width: layout.barWidth,
             }
           }
+          kWidthPx = layout.kWidthPx
         } else {
           kWidthPx = getPhysicalKLineConfig(opt.kWidth, opt.kGap, vp.dpr).kWidthPx
         }
@@ -826,7 +831,13 @@ export class ChartRenderer {
           plotWidth: vp.plotWidth,
           plotHeight: vp.plotHeight,
         },
-        settings: this.settings,
+        settings: {
+          ...this.settings,
+          // 分时昨收优先读 series 元数据，settings 作回退
+          preClose:
+            dataManager.getTimeSharePreClose() ??
+            (this.settings.preClose as number | undefined),
+        },
         yAxisLabels: sharedYAxisLabels,
         xAxisLabels: sharedXAxisLabels,
         yAxisRanges: sharedYAxisRanges,