opencode-cache-hit 0.1.0

package/src/main-session-view.tsx

@@ -0,0 +1,76 @@
+/** @jsxImportSource @opentui/solid */
+import { Show } from "solid-js"
+import { TokenDetailRows } from "./cache-hit-rows.tsx"
+import type { CacheHitMetrics } from "./use-cache-hit-metrics.ts"
+import {
+  TuiHitRow,
+  TuiMetricRow,
+  TuiSection,
+  type PanelLayout,
+  type SectionFold,
+} from "./tui-panel/index.ts"
+
+export function MainSessionView(props: {
+  m: CacheHitMetrics
+  layout: PanelLayout
+  detail: SectionFold
+  model: SectionFold
+  formatCost: (n: number) => string
+}) {
+  const { m, layout } = props
+  return (
+    <>
+      <TuiHitRow
+        label={m.hitLabel()}
+        bar={m.bar()}
+        pct={m.pctLabel()}
+        barColor={m.hitColor()}
+        textColor={m.pal().text}
+        trend={
+          m.perCall().hasTrend ? { text: m.trendLabel(), color: m.trendFg() } : undefined
+        }
+      />
+      <TuiMetricRow pal={m.pal()} layout={layout} label={m.t().totalHit} value={m.sessionPct()} />
+
+      <TuiSection
+        pal={m.pal()}
+        layout={layout}
+        open={props.detail.open()}
+        title={m.t().secDetail}
+        onToggle={props.detail.toggle}
+      >
+        <TokenDetailRows pal={m.pal()} layout={layout} t={m.t()} snap={m.main()}>
+          <Show when={m.showCombinedHit()}>
+            <TuiMetricRow
+              pal={m.pal()}
+              layout={layout}
+              label={m.t().withAgents}
+              value={m.combinedPct()}
+            />
+          </Show>
+        </TokenDetailRows>
+      </TuiSection>
+
+      <TuiSection
+        pal={m.pal()}
+        layout={layout}
+        open={props.model.open()}
+        title={m.t().secModel}
+        onToggle={props.model.toggle}
+      >
+        <Show when={m.main().cost > 0}>
+          <TuiMetricRow
+            pal={m.pal()}
+            layout={layout}
+            label={m.t().cost}
+            value={props.formatCost(m.main().cost)}
+            fg={m.pal().text}
+          />
+        </Show>
+        <Show when={m.modelShort()}>
+          <TuiMetricRow pal={m.pal()} layout={layout} label={m.t().model} value={m.modelShort()} />
+        </Show>
+      </TuiSection>
+    </>
+  )
+}

package/src/message-timing.ts

@@ -0,0 +1,35 @@
+import type { AssistantMessage } from "./types.ts"
+
+/** Milliseconds since epoch (OpenCode SDK v2). */
+export type MessageTiming = {
+  created: number
+  completedAt?: number
+  durationMs?: number
+  isComplete: boolean
+}
+
+/**
+ * Per-call timing from AssistantMessage.time (SDK).
+ * - created: always set when message exists
+ * - completed: set when the LLM turn finishes (reliable for finished calls)
+ * Use completed ?? created for ordering finished calls; in-flight calls lack completed.
+ */
+export function timingFromAssistantMessage(msg: AssistantMessage): MessageTiming | null {
+  const t = msg.time
+  if (!t || typeof t.created !== "number") return null
+  const completedAt = typeof t.completed === "number" ? t.completed : undefined
+  return {
+    created: t.created,
+    completedAt,
+    durationMs: completedAt !== undefined ? completedAt - t.created : undefined,
+    isComplete: completedAt !== undefined,
+  }
+}
+
+export function formatTimingShort(ms: number): string {
+  const d = new Date(ms)
+  const h = String(d.getHours()).padStart(2, "0")
+  const m = String(d.getMinutes()).padStart(2, "0")
+  const s = String(d.getSeconds()).padStart(2, "0")
+  return `${h}:${m}:${s}`
+}

package/src/plugin-config.ts

@@ -0,0 +1,116 @@
+import { type CostDisplayConfig, normalizeCostDisplay, DEFAULT_COST_DISPLAY } from "./format-cost.ts"
+import { resolveLang, type Lang } from "./i18n.ts"
+
+export type DisplayConfig = {
+  /** `en` | `zh` | `auto` (follow system locale). Default `en`. */
+  lang: Lang | "auto"
+  /** Optional override for the hit-rate line prefix (default from i18n). */
+  mainHitLabel?: string
+  /** Outer panel border (visual-cache style). Default true. */
+  panelBorder: boolean
+  /** @deprecated Use panelBorder */
+  agentsBorder?: boolean
+}
+
+export const DEFAULT_DISPLAY: DisplayConfig = {
+  lang: "en",
+  panelBorder: true,
+}
+
+export type TimelineConfig = {
+  enabled: boolean
+  /** Empty → plugin `logs/` directory */
+  dir: string
+  flushIncomplete: boolean
+  logSummaryMessages: boolean
+  maxMemoryRows: number
+  /** 0 = unlimited; after each append keep only the last N lines in the active file */
+  maxLinesPerFile: number
+  /** 0 = off; when active file reaches this size (bytes), roll to `.jsonl.1` before append */
+  rotateMaxBytes: number
+  /** How many rotated backups to keep (`file.jsonl.1` … `.N`); 0 = delete on roll */
+  retainRotated: number
+  /** 0 = off; delete `*.jsonl*` in log dir older than N days (on collector start) */
+  maxAgeDays: number
+  /** 0 = unlimited; max number of `*.jsonl*` files in log dir (oldest mtime deleted first) */
+  maxLogFiles: number
+}
+
+export const DEFAULT_TIMELINE: TimelineConfig = {
+  enabled: false,
+  dir: "",
+  flushIncomplete: false,
+  logSummaryMessages: true,
+  maxMemoryRows: 50,
+  maxLinesPerFile: 0,
+  rotateMaxBytes: 0,
+  retainRotated: 5,
+  maxAgeDays: 0,
+  maxLogFiles: 0,
+}
+
+export type PluginConfig = {
+  cost: CostDisplayConfig
+  display: DisplayConfig
+  timeline: TimelineConfig
+}
+
+export const DEFAULT_PLUGIN_CONFIG: PluginConfig = {
+  cost: { ...DEFAULT_COST_DISPLAY },
+  display: { ...DEFAULT_DISPLAY },
+  timeline: { ...DEFAULT_TIMELINE },
+}
+
+export function normalizeTimelineConfig(raw: unknown): TimelineConfig {
+  const t = { ...DEFAULT_TIMELINE }
+  if (!raw || typeof raw !== "object") return t
+  const o = raw as Record<string, unknown>
+  if (typeof o.enabled === "boolean") t.enabled = o.enabled
+  if (typeof o.dir === "string") t.dir = o.dir
+  if (typeof o.flushIncomplete === "boolean") t.flushIncomplete = o.flushIncomplete
+  if (typeof o.logSummaryMessages === "boolean") t.logSummaryMessages = o.logSummaryMessages
+  if (typeof o.maxMemoryRows === "number" && o.maxMemoryRows > 0) {
+    t.maxMemoryRows = Math.floor(o.maxMemoryRows)
+  }
+  if (typeof o.maxLinesPerFile === "number" && o.maxLinesPerFile >= 0) {
+    t.maxLinesPerFile = Math.floor(o.maxLinesPerFile)
+  }
+  if (typeof o.rotateMaxBytes === "number" && o.rotateMaxBytes >= 0) {
+    t.rotateMaxBytes = Math.floor(o.rotateMaxBytes)
+  }
+  if (typeof o.retainRotated === "number" && o.retainRotated >= 0) {
+    t.retainRotated = Math.floor(o.retainRotated)
+  }
+  if (typeof o.maxAgeDays === "number" && o.maxAgeDays >= 0) {
+    t.maxAgeDays = Math.floor(o.maxAgeDays)
+  }
+  if (typeof o.maxLogFiles === "number" && o.maxLogFiles >= 0) {
+    t.maxLogFiles = Math.floor(o.maxLogFiles)
+  }
+  return t
+}
+
+export function normalizeDisplayConfig(raw: unknown): DisplayConfig {
+  const d = { ...DEFAULT_DISPLAY }
+  if (!raw || typeof raw !== "object") return d
+  const o = raw as Record<string, unknown>
+  if (typeof o.lang === "string") {
+    d.lang = o.lang === "auto" ? "auto" : resolveLang(o.lang)
+  }
+  if (typeof o.mainHitLabel === "string" && o.mainHitLabel.length > 0) d.mainHitLabel = o.mainHitLabel
+  if (typeof o.panelBorder === "boolean") d.panelBorder = o.panelBorder
+  else if (typeof o.agentsBorder === "boolean") d.panelBorder = o.agentsBorder
+  return d
+}
+
+export function normalizePluginConfig(raw: unknown): PluginConfig {
+  if (!raw || typeof raw !== "object") return { ...DEFAULT_PLUGIN_CONFIG }
+  const o = raw as Record<string, unknown>
+  const cost = normalizeCostDisplay(raw)
+  const displayRaw = o.display
+  return {
+    cost,
+    display: normalizeDisplayConfig(displayRaw),
+    timeline: normalizeTimelineConfig(o.timeline),
+  }
+}

package/src/plugin.tsx

@@ -0,0 +1,33 @@
+/** @jsxImportSource @opentui/solid */
+import { CacheHitSidebarHost } from "./sidebar-host.tsx"
+import { loadPluginConfig } from "./load-config.ts"
+import { createCostFormatter } from "./format-cost.ts"
+import type { OpenCodeTuiApi } from "./types.ts"
+
+export const PLUGIN_ID = "opencode-cache-hit"
+
+export const tui = async (api: OpenCodeTuiApi) => {
+  const pluginConfig = loadPluginConfig()
+  const formatCost = createCostFormatter(pluginConfig.cost)
+
+  api.slots.register({
+    order: 56,
+    slots: {
+      sidebar_content(ctx, props) {
+        return (
+          <CacheHitSidebarHost
+            sessionId={props.session_id ?? ""}
+            theme={ctx.theme.current}
+            display={pluginConfig.display}
+            timeline={pluginConfig.timeline}
+            formatCost={formatCost}
+            api={api}
+          />
+        )
+      },
+    },
+  })
+}
+
+const plugin = { id: PLUGIN_ID, tui }
+export default plugin

package/src/session-list.ts

@@ -0,0 +1,11 @@
+export type SessionListEntry = { id: string; parentID?: string }
+
+export function parseSessionListResponse(all: unknown): SessionListEntry[] {
+  const list = Array.isArray(all) ? all : ((all as { data?: unknown })?.data ?? [])
+  if (!Array.isArray(list)) return []
+  return list as SessionListEntry[]
+}
+
+export function childSessionIdsForParent(list: SessionListEntry[], parentId: string): string[] {
+  return list.filter((s) => s.parentID === parentId).map((s) => s.id)
+}

package/src/sidebar-host.tsx

@@ -0,0 +1,121 @@
+/** @jsxImportSource @opentui/solid */
+import { createSignal, createMemo, createEffect, onCleanup } from "solid-js"
+import { CacheHitSidebar } from "./widget.tsx"
+import type { DisplayConfig, TimelineConfig } from "./plugin-config.ts"
+import { createTimelineCollector } from "./timeline/collector.ts"
+import type { AssistantMessage, OpenCodeTuiApi, SubAgentSummary } from "./types.ts"
+import {
+  emptySessionSnapshot,
+  aggregateSessionFromMessages,
+  subAgentHasStats,
+  toSubAgentSummary,
+} from "./stats.ts"
+import { createChildSessionSync } from "./child-session-sync.ts"
+import { loadPluginConfig } from "./load-config.ts"
+
+/**
+ * Session-scoped sidebar host. Bumps `refreshTick` on message.updated (same as visual-cache)
+ * so memos re-read api.state.session.messages.
+ */
+export function CacheHitSidebarHost(props: {
+  sessionId: string
+  theme: Record<string, unknown>
+  display: DisplayConfig
+  timeline: TimelineConfig
+  formatCost: (amount: number) => string
+  api: OpenCodeTuiApi
+}) {
+  const [refreshTick, setRefreshTick] = createSignal(0)
+  const [childIds, setChildIds] = createSignal<string[]>([])
+
+  /** Re-read cache-hit.config.json when parent session changes (picks up edits without full plugin reload). */
+  const runtimeConfig = createMemo(() => {
+    void props.sessionId
+    return loadPluginConfig()
+  })
+  const display = createMemo(() => runtimeConfig().display)
+
+  const bumpRefresh = () => setRefreshTick((v) => v + 1)
+
+  const timeline = createTimelineCollector({
+    config: props.timeline,
+    getRootSessionId: () => props.sessionId,
+    getChildIds: childIds,
+    getMessages: (id) =>
+      (props.api.state.session.messages(id) ?? []) as AssistantMessage[],
+  })
+  onCleanup(() => timeline.dispose())
+
+  const childSync = createChildSessionSync({
+    client: props.api.client.session,
+    getDirectory: () => props.api.state.path.directory,
+    getParentId: () => props.sessionId,
+    setChildIds,
+    onSynced: () => {
+      bumpRefresh()
+      timeline.schedule()
+    },
+  })
+  onCleanup(() => childSync.dispose())
+
+  const mainSnap = createMemo(() => {
+    void refreshTick()
+    const sid = props.sessionId
+    if (!sid) return emptySessionSnapshot()
+    const msgs = props.api.state.session.messages(sid)
+    return msgs?.length
+      ? aggregateSessionFromMessages(msgs as AssistantMessage[])
+      : emptySessionSnapshot()
+  })
+
+  const mainMessages = createMemo(() => {
+    void refreshTick()
+    const sid = props.sessionId
+    if (!sid) return [] as AssistantMessage[]
+    return (props.api.state.session.messages(sid) ?? []) as AssistantMessage[]
+  })
+
+  const subAgentList = createMemo(() =>
+    childIds()
+      .map((cid) => {
+        const msgs = props.api.state.session.messages(cid)
+        if (!msgs?.length) return null
+        const snap = aggregateSessionFromMessages(msgs as AssistantMessage[])
+        if (!subAgentHasStats(snap)) return null
+        return toSubAgentSummary(cid, snap)
+      })
+      .filter(Boolean) as SubAgentSummary[],
+  )
+
+  createEffect(() => {
+    const sid = props.sessionId
+    void props.api.state.path.directory
+    childSync.resetForParentChange()
+    timeline.resetForRootChange()
+    if (sid) {
+      childSync.loadChildren()
+      timeline.schedule()
+    }
+  })
+
+  createEffect(() => {
+    const unsub = props.api.event.on("message.updated", (event) => {
+      bumpRefresh()
+      childSync.onForeignSessionActivity(event.properties?.info?.sessionID)
+      timeline.schedule()
+    })
+    onCleanup(() => unsub?.())
+  })
+
+  return (
+    <CacheHitSidebar
+      sessionId={() => props.sessionId}
+      theme={props.theme}
+      display={display()}
+      messages={mainMessages}
+      main={mainSnap}
+      subAgents={subAgentList}
+      formatCost={props.formatCost}
+    />
+  )
+}

package/src/stats.ts

@@ -0,0 +1,141 @@
+import type { AssistantMessage, SessionSnapshot, SubAgentSummary } from "./types.ts"
+
+export function mainSessionHasStats(main: SessionSnapshot): boolean {
+  return (
+    main.cacheRead > 0 ||
+    main.cacheWrite > 0 ||
+    main.cost > 0 ||
+    main.input > 0 ||
+    main.output > 0
+  )
+}
+
+export function emptySessionSnapshot(): SessionSnapshot {
+  return { model: "", input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }
+}
+
+export function aggregateSessionFromMessages(messages: readonly AssistantMessage[]): SessionSnapshot {
+  let model = "",
+    input = 0,
+    output = 0,
+    reasoning = 0,
+    cacheRead = 0,
+    cacheWrite = 0,
+    cost = 0
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue
+    const t = msg.tokens ?? {}
+    input += t.input ?? 0
+    output += t.output ?? 0
+    reasoning += t.reasoning ?? 0
+    cacheRead += t.cache?.read ?? 0
+    cacheWrite += t.cache?.write ?? 0
+    cost += msg.cost ?? 0
+    if (msg.modelID) model = msg.modelID
+  }
+  return { model, input, output, reasoning, cacheRead, cacheWrite, cost }
+}
+
+export function toSubAgentSummary(id: string, snap: SessionSnapshot): SubAgentSummary {
+  return {
+    id,
+    cost: snap.cost,
+    input: snap.input,
+    output: snap.output,
+    reasoning: snap.reasoning,
+    cacheRead: snap.cacheRead,
+    cacheWrite: snap.cacheWrite,
+  }
+}
+
+export function aggregateSubAgents(subs: readonly SubAgentSummary[]): SessionSnapshot {
+  const total = emptySessionSnapshot()
+  for (const s of subs) {
+    total.input += s.input
+    total.output += s.output
+    total.reasoning += s.reasoning
+    total.cacheRead += s.cacheRead
+    total.cacheWrite += s.cacheWrite
+    total.cost += s.cost
+  }
+  return total
+}
+
+export function cacheHitRatio(cacheRead: number, input: number): number {
+  const denom = cacheRead + input
+  return denom > 0 ? cacheRead / denom : 0
+}
+
+export function combinedCacheHitRatio(
+  main: SessionSnapshot,
+  subs: readonly Pick<SubAgentSummary, "cacheRead" | "input">[],
+): number {
+  let cacheRead = main.cacheRead
+  let input = main.input
+  for (const s of subs) {
+    cacheRead += s.cacheRead
+    input += s.input
+  }
+  return cacheHitRatio(cacheRead, input)
+}
+
+export function subAgentHasStats(snap: SessionSnapshot): boolean {
+  return (
+    snap.cost > 0 ||
+    snap.cacheRead > 0 ||
+    snap.cacheWrite > 0 ||
+    snap.input > 0 ||
+    snap.output > 0 ||
+    snap.reasoning > 0
+  )
+}
+
+export function sidebarShouldShow(
+  main: SessionSnapshot,
+  subs: readonly SubAgentSummary[],
+): boolean {
+  return subs.length > 0 || mainSessionHasStats(main)
+}
+
+export type PerCallHitTrend = {
+  hitPercent: number
+  trendPercent: number
+  hasTrend: boolean
+}
+
+/** Single assistant turn hit % (0–100), or null if skipped / no denominator. */
+export function perMessageHitPercent(msg: AssistantMessage): number | null {
+  if (msg.role !== "assistant" || msg.summary === true) return null
+  const t = msg.tokens
+  if (!t) return null
+  const input = t.input ?? 0
+  const read = t.cache?.read ?? 0
+  const denom = read + input
+  if (denom <= 0) return null
+  return (read / denom) * 100
+}
+
+/**
+ * Per-turn hit rates for the top Hit row (visual-cache).
+ * Skips `summary: true` assistant messages — not full LLM pricing turns.
+ */
+export function computePerCallHitTrend(messages: readonly AssistantMessage[]): PerCallHitTrend {
+  let prevHit = -1
+  let lastHit = -1
+  for (const msg of messages) {
+    const hit = perMessageHitPercent(msg)
+    if (hit === null) continue
+    prevHit = lastHit
+    lastHit = hit
+  }
+  return {
+    hitPercent: lastHit >= 0 ? lastHit : 0,
+    trendPercent: prevHit >= 0 && lastHit >= 0 ? lastHit - prevHit : 0,
+    hasTrend: prevHit >= 0 && lastHit >= 0,
+  }
+}
+
+export function shortModelName(modelId: string): string {
+  if (!modelId) return ""
+  return modelId.includes("/") ? (modelId.split("/").pop() ?? modelId) : modelId
+}

package/src/timeline/collector.ts

@@ -0,0 +1,156 @@
+import type { TimelineConfig } from "../plugin-config.ts"
+import type { AssistantMessage } from "../types.ts"
+import { buildCallRecords, mergeAndSortRecords } from "./records.ts"
+import {
+  appendTimelineRecord,
+  localDateKey,
+  purgeTimelineLogDir,
+  resolveTimelineDir,
+  timelineDailyLogPath,
+} from "./writer.ts"
+import type { LlmCallRecord } from "./types.ts"
+
+export const TIMELINE_DEBOUNCE_MS = 500
+
+export type TimelineCollector = {
+  schedule: () => void
+  resetForRootChange: () => void
+  dispose: () => void
+  memoryRecords: () => readonly LlmCallRecord[]
+}
+
+export function createTimelineCollector(opts: {
+  config: TimelineConfig
+  getRootSessionId: () => string
+  getChildIds: () => readonly string[]
+  getMessages: (sessionId: string) => readonly AssistantMessage[]
+  /** Test hook: replace disk append */
+  append?: (logPath: string, record: LlmCallRecord) => Promise<void>
+}): TimelineCollector {
+  if (!opts.config.enabled) {
+    return {
+      schedule: () => {},
+      resetForRootChange: () => {},
+      dispose: () => {},
+      memoryRecords: () => [],
+    }
+  }
+
+  const logsDir = resolveTimelineDir(opts.config)
+  const rotation = {
+    maxLinesPerFile: opts.config.maxLinesPerFile,
+    rotateMaxBytes: opts.config.rotateMaxBytes,
+    retainRotated: opts.config.retainRotated,
+  }
+  const append =
+    opts.append ??
+    ((path, rec) => appendTimelineRecord(path, rec, rotation))
+  if (opts.config.maxAgeDays > 0 || opts.config.maxLogFiles > 0) {
+    void purgeTimelineLogDir(logsDir, {
+      maxAgeDays: opts.config.maxAgeDays,
+      maxLogFiles: opts.config.maxLogFiles,
+    })
+  }
+  const flushedKeys = new Set<string>()
+  let activeDateKey = localDateKey()
+  let debounceTimer: ReturnType<typeof setTimeout> | undefined
+  let memory: LlmCallRecord[] = []
+  let collectGen = 0
+
+  const ensureDateKey = () => {
+    const today = localDateKey()
+    if (today !== activeDateKey) {
+      flushedKeys.clear()
+      activeDateKey = today
+    }
+    return today
+  }
+
+  const clearDebounce = () => {
+    if (debounceTimer !== undefined) clearTimeout(debounceTimer)
+    debounceTimer = undefined
+  }
+
+  const shouldFlushToDisk = (rec: LlmCallRecord): boolean => {
+    if (flushedKeys.has(rec.messageKey)) return false
+    if (rec.isComplete) return true
+    return opts.config.flushIncomplete
+  }
+
+  const flushRecords = async (records: LlmCallRecord[], rootId: string, gen: number) => {
+    const logPath = timelineDailyLogPath(logsDir, ensureDateKey())
+    for (const rec of records) {
+      if (gen !== collectGen || opts.getRootSessionId() !== rootId) return
+      if (!shouldFlushToDisk(rec)) continue
+      flushedKeys.add(rec.messageKey)
+      try {
+        await append(logPath, rec)
+      } catch {
+        flushedKeys.delete(rec.messageKey)
+      }
+    }
+  }
+
+  const collectNow = () => {
+    clearDebounce()
+    const rootId = opts.getRootSessionId()
+    if (!rootId) {
+      memory = []
+      return
+    }
+    const gen = collectGen
+    const chunks: LlmCallRecord[][] = []
+    const mainMsgs = opts.getMessages(rootId)
+    if (mainMsgs.length) {
+      chunks.push(
+        buildCallRecords(rootId, rootId, "main", mainMsgs, {
+          logSummaryMessages: opts.config.logSummaryMessages,
+        }),
+      )
+    }
+    for (const cid of opts.getChildIds()) {
+      const msgs = opts.getMessages(cid)
+      if (msgs.length) {
+        chunks.push(
+          buildCallRecords(cid, rootId, "child", msgs, {
+            logSummaryMessages: opts.config.logSummaryMessages,
+          }),
+        )
+      }
+    }
+    if (gen !== collectGen || opts.getRootSessionId() !== rootId) return
+    memory = mergeAndSortRecords(chunks)
+    const toFlush = memory.filter(shouldFlushToDisk)
+    if (toFlush.length > 0) {
+      queueMicrotask(() => flushRecords(toFlush, rootId, gen))
+    }
+  }
+
+  const schedule = () => {
+    clearDebounce()
+    if (!opts.getRootSessionId()) return
+    debounceTimer = setTimeout(() => {
+      debounceTimer = undefined
+      collectNow()
+    }, TIMELINE_DEBOUNCE_MS)
+  }
+
+  const resetForRootChange = () => {
+    collectGen++
+    clearDebounce()
+    memory = []
+  }
+
+  const dispose = () => {
+    collectGen++
+    clearDebounce()
+  }
+
+  const memoryRecords = () => {
+    const max = opts.config.maxMemoryRows
+    if (memory.length <= max) return memory
+    return memory.slice(-max)
+  }
+
+  return { schedule, resetForRootChange, dispose, memoryRecords }
+}