1
// policy的名字，可以自定义，这里仅为示范
2
const CONTRACT_FRONTEND_HTML_POLICY = 'contract-frontend-html'
3

4
export const TRUSTED_TYPES_POLICY_NAME = CONTRACT_FRONTEND_HTML_POLICY
5

6
// 这个类型代表装载的value已经是经过sanitized的HTML。
7
export type SanitizedHtmlInput = {
8
  readonly kind: 'sanitized-html'
9
  readonly value: string
10
}
11

12
// 统一Policy的内容，一个是HTML，一个是ScriptURL
189 collapsed lines
13
type TrustedTypesPolicyShape = {
14
  createHTML(input: string): string
15
  createScriptURL?(input: string): string
16
}
17

18
// 规范TrustedTypesPolicyFactory的类型
19
type TrustedTypesPolicyFactory = {
20
  createPolicy(name: string, rules: TrustedTypesPolicyShape): TrustedTypesPolicyShape
21
}
22

23
let trustedTypesPolicy: TrustedTypesPolicyShape | null | undefined
24
let trustedTypesPolicyFactory: TrustedTypesPolicyFactory | null | undefined
25

26
// 调用方不能直接传字符串给 HTML policy，而要先wrap。
27
export const asSanitizedHtmlInput = (value: string): SanitizedHtmlInput => ({
28
  kind: 'sanitized-html',
29
  value,
30
})
31

32
// 获取从factory中得到的TrustedHTML
33
export const createTrustedHtmlFromSanitized = (input: SanitizedHtmlInput | unknown) => {
34
  // 检查input
35
  const payload = assertSanitizedHtmlInput(input)
36
  // 返回TrustedHTML，sanitize在之前已经完成了，这个相当于盖章。（虽然什么都没做，但还是辛苦它了）
37
  // 这里也有降级处理，如果浏览器不支持Trusted Types，返回原始string
38
  return getContractFrontendHtmlPolicy()?.createHTML(payload.value) ?? payload.value
39
}
40

41
// 检查：
42
// kind === 'sanitized-html'
43
// typeof value === 'string'
44
// 不符合要求就抛错：createTrustedHtmlFromSanitized requires SanitizedHtmlInput
45
function assertSanitizedHtmlInput(value: unknown): SanitizedHtmlInput {
46
  if (
47
    typeof value !== 'object' ||
48
    value === null ||
49
    !('kind' in value) ||
50
    !('value' in value) ||
51
    (value as { kind?: string }).kind !== 'sanitized-html' ||
52
    typeof (value as { value?: unknown }).value !== 'string'
53
  ) {
54
    throw new TypeError('createTrustedHtmlFromSanitized requires SanitizedHtmlInput')
55
  }
56

57
  return value as SanitizedHtmlInput
58
}
59

60
// 复用创建的html policy
61
export const getContractFrontendHtmlPolicy = () => {
62
  const factory = getTrustedTypesFactory()
63

64
  if (trustedTypesPolicy !== undefined) {
65
    if (trustedTypesPolicyFactory === factory) {
66
      return trustedTypesPolicy
67
    }
68
  }
69

70
  if (!factory) {
71
    trustedTypesPolicyFactory = null
72
    trustedTypesPolicy = null
73
    return trustedTypesPolicy
74
  }
75

76
  trustedTypesPolicyFactory = factory
77
  trustedTypesPolicy = factory.createPolicy(CONTRACT_FRONTEND_HTML_POLICY, {
78
    createHTML(input) {
79
      // 考虑到不同场景需要不同的sanitizer profile，所以不在这里做统一的input清洗处理。
80
      return input
81
    },
82
    createScriptURL(input) {
83
      // 同上，我们的sanitizer步骤不在这里进行。
84
      return input
85
    },
86
  })
87

88
  return trustedTypesPolicy
89
}
90

91
// 获取Trusted Types实例
92
const getTrustedTypesFactory = (): TrustedTypesPolicyFactory | null => {
93
  if (typeof window === 'undefined' || typeof window.trustedTypes === 'undefined') {
94
    return null
95
  }
96

97
  return window.trustedTypes as TrustedTypesPolicyFactory
98
}
99

100
// 给类似于OpenReplay的类似于worker blob URL使用。
101
// 这类第三方库可能会涉及到这样的操作：new Worker('blob:https://...')
102
// 将blob:URL像上面那样，变成TrustedScriptURL，避免触发violation，这并非跳过检查，而是不让本身受信内容触发csp violation report。
103
export const createTrustedScriptUrl = (input: string) =>
104
  getContractFrontendHtmlPolicy()?.createScriptURL?.(input) ?? input
105

106
// 需要颁发受信的ScriptURL规则，这里比较粗，意思意思。
107
const needsTrustedWorkerScriptUrl = (value: unknown): value is string =>
108
  typeof value === 'string' && value.startsWith('blob:')
109

110
// 接收 scriptURL 和 options，new出来一个worker
111
type WorkerConstructor = {
112
  new (scriptURL: string | URL, options?: WorkerOptions): Worker
113
  prototype: Worker
114
}
115

116
// 同上，这个worker可以同源跨标签生效，共享context。
117
type SharedWorkerConstructor = {
118
  new (scriptURL: string | URL, options?: string | WorkerOptions): SharedWorker
119
  prototype: SharedWorker
120
}
121

122
// 传进来一个原生的构造器，返回一个包装后的构造器。
123
const wrapWorkerConstructor = <TConstructor extends WorkerConstructor | SharedWorkerConstructor>(
124
  NativeConstructor: TConstructor,
125
) => {
126
  const TrustedWorkerConstructor = function WorkerConstructor(
127
    this: Worker | SharedWorker,
128
    scriptURL: string | URL,
129
    options?: string | WorkerOptions,
130
  ) {
131
    // 处理blob: 开头的scriptURL，但不用改第三方的代码，让其变成Trusted scriptURL。
132
    const nextScriptURL = needsTrustedWorkerScriptUrl(scriptURL)
133
      ? createTrustedScriptUrl(scriptURL)
134
      : scriptURL
135
  // 可以粗暴理解成return new NativeConstructor(nextScriptURL, options)
136
    // 为什么要这么写后面会有解释，包括prototype的赋值。
137
    return Reflect.construct(
138
      NativeConstructor,
139
      [nextScriptURL, options],
140
      new.target ?? NativeConstructor,
141
    )
142
  } as unknown as TConstructor
143
  // TrustedWorkerConstructor.prototype这个对象被创建出来之后是个空值（默认就是如此）
144
  // Reflect.construct(NativeConstructor, args, new.target)创建的实例_proto_会引用TrustedWorkerConstructor.prototype，而不是NativeWorker.prototype。
145
  // 而TrustedWorkerConstructor.prototype要手动赋值一下，因为创建的function默认的prototype是一个默认的几乎为空对象的值，得跟对应的NativeWorker.prototype对齐。
146
  TrustedWorkerConstructor.prototype = NativeConstructor.prototype
147
  // 这样最终的TrustedWorker就只是将nextScriptURL代理了一下，其它的行为完全对齐原来的NativeWorker，不影响原有的任何行为，从而达到不修改第三方代码但完成了自己的目的。
148
  return TrustedWorkerConstructor
149
}
150
// 在globalThis中挂载两个修改过的worker，返回一个可以恢复为原生worker的函数。
151
// 这样初始化失败时，测试中需要清理状态时，可以变回原生Worker，既然做了就要提供undo的fn。
152
export function installTrustedTypesWorkerConstructors(): (() => void) | null {
153
  if (typeof window === 'undefined' || typeof window.trustedTypes === 'undefined') {
154
    return null
155
  }
156

157
  const NativeWorker = globalThis.Worker
158
  const NativeSharedWorker = globalThis.SharedWorker
159
  let installedWorker = false
160
  let installedSharedWorker = false
161

162
  if (typeof NativeWorker === 'function') {
163
    Object.defineProperty(globalThis, 'Worker', {
164
      configurable: true,
165
      writable: true,
166
      value: wrapWorkerConstructor(NativeWorker),
167
    })
168
    installedWorker = true
169
  }
170

171
  if (typeof NativeSharedWorker === 'function') {
172
    Object.defineProperty(globalThis, 'SharedWorker', {
173
      configurable: true,
174
      writable: true,
175
      value: wrapWorkerConstructor(NativeSharedWorker),
176
    })
177
    installedSharedWorker = true
178
  }
179

180
  if (!installedWorker && !installedSharedWorker) {
181
    return null
182
  }
183

184
  return () => {
185
    if (installedWorker) {
186
      Object.defineProperty(globalThis, 'Worker', {
187
        configurable: true,
188
        writable: true,
189
        value: NativeWorker,
190
      })
191
    }
192

193
    if (installedSharedWorker) {
194
      Object.defineProperty(globalThis, 'SharedWorker', {
195
        configurable: true,
196
        writable: true,
197
        value: NativeSharedWorker,
198
      })
199
    }
200
  }
201
}

1
import DOMPurify, { type Config as DOMPurifyConfig } from 'dompurify'
2
import { getContractFrontendHtmlPolicy } from '@/modules/shared/application/security/trusted-types'
3
// Markdown HTML 清洗
4
const MARKDOWN_HTML_CONFIG: DOMPurifyConfig = {
5
  USE_PROFILES: { html: true },
6
  FORBID_TAGS: ['script', 'style', 'iframe'],
7
  FORBID_ATTR: ['srcdoc'],
8
  ALLOW_DATA_ATTR: true,
9
  RETURN_TRUSTED_TYPE: false,
10
}
11
// Mermaid SVG 清洗
12
const MARKDOWN_SVG_CONFIG: DOMPurifyConfig = {
31 collapsed lines
13
  USE_PROFILES: { svg: true, svgFilters: true },
14
  // 禁用<foreignObject>、<script>、<style>
15
  FORBID_TAGS: ['foreignObject', 'script', 'style'],
16
  // 禁用srcdoc属性
17
  FORBID_ATTR: ['srcdoc'],
18
  // 允许data-*的属性
19
  ALLOW_DATA_ATTR: true,
20
  RETURN_TRUSTED_TYPE: false,
21
}
22

23
function sanitizeHtmlWithConfig(input: string, config: DOMPurifyConfig) {
24
  const trustedTypesPolicy = getContractFrontendHtmlPolicy()
25

26
  return DOMPurify.sanitize(input, {
27
    ...config,
28
    ...(trustedTypesPolicy
29
      ? {
30
          TRUSTED_TYPES_POLICY:
31
            trustedTypesPolicy as unknown as DOMPurifyConfig['TRUSTED_TYPES_POLICY'],
32
        }
33
      : {}),
34
  })
35
}
36

37
export function sanitizeMarkdownHtml(html: string) {
38
  return sanitizeHtmlWithConfig(html, MARKDOWN_HTML_CONFIG)
39
}
40

41
export async function sanitizeMarkdownMermaid(svg: string) {
42
  return sanitizeHtmlWithConfig(svg, MARKDOWN_SVG_CONFIG)
43
}

1
import { defineComponent, h, type Component } from 'vue'
2
import { sanitizeMarkdownHtml, sanitizeMarkdownMermaid } from './markdown-security'
3

4

5
// 运行时promise缓存，防止同一套runtime被重复初始化，多个editor组件同时出现时只初始化一次。
6
let mdPreviewRuntimePromise: Promise<void> | null = null
7
let mdEditorRuntimePromise: Promise<void> | null = null
8

9
function disableMarkdownRawHtml(md: { options: { html?: boolean } }) {
10
  // 关闭markdown的html
11
  md.options.html = false
12
}
127 collapsed lines
13

14
// mermaid 配置显式传递 strict，不依赖默认值。
15
function createStrictMermaidConfig<TConfig extends Record<string, unknown>>(config: TConfig) {
16
  return {
17
    ...config,
18
    securityLevel: 'strict',
19
  }
20
}
21

22
// 安全配置
23
const markdownSecurityConfig = {
24
  markdownItConfig: disableMarkdownRawHtml,
25
  mermaidConfig: createStrictMermaidConfig,
26
}
27

28
// 这个主要是做兼容ESM/CJS默认导出差异，有些依赖导入后是module.default，有些依赖直接就是instance，统一flat成instance，避免到处判断。
29
function resolveModuleDefault<T>(module: T | { default: T }): T {
30
  if (typeof module === 'object' && module !== null && 'default' in module) {
31
    return module.default
32
  }
33

34
  return module as T
35
}
36

37
// 动态导入preview所需依赖（包含样式）
38
async function ensureMdPreviewRuntime() {
39
  if (!mdPreviewRuntimePromise) {
40
    mdPreviewRuntimePromise = (async () => {
41
      const [{ config }, highlightModule, mermaidModule, katexModule] = await Promise.all([
42
        import('md-editor-v3'),
43
        import('highlight.js'),
44
        import('mermaid'),
45
        import('katex'),
46
        import('highlight.js/styles/atom-one-light.css'),
47
        import('katex/dist/katex.min.css'),
48
      ])
49

50
      config({
51
        ...markdownSecurityConfig,
52
        editorExtensions: {
53
          highlight: {
54
            instance: resolveModuleDefault(highlightModule),
55
          },
56
          mermaid: {
57
            instance: resolveModuleDefault(mermaidModule),
58
          },
59
          katex: {
60
            instance: resolveModuleDefault(katexModule),
61
          },
62
        },
63
      })
64
    })()
65
  }
66

67
  return mdPreviewRuntimePromise
68
}
69

70
// 动态导入runtime所需依赖，对比preview，多了格式化、全屏之类的功能。
71
async function ensureMdEditorRuntime() {
72
  if (!mdEditorRuntimePromise) {
73
    mdEditorRuntimePromise = (async () => {
74
      await ensureMdPreviewRuntime()
75

76
      const [{ config }, prettierModule, parserMarkdownModule, cropperModule, screenfullModule] =
77
        await Promise.all([
78
          import('md-editor-v3'),
79
          import('prettier/standalone'),
80
          import('prettier/plugins/markdown'),
81
          import('cropperjs'),
82
          import('screenfull'),
83
          import('cropperjs/dist/cropper.css'),
84
        ])
85

86
      config({
87
        ...markdownSecurityConfig,
88
        editorExtensions: {
89
          prettier: {
90
            prettierInstance: resolveModuleDefault(prettierModule),
91
            parserMarkdownInstance: resolveModuleDefault(parserMarkdownModule),
92
          },
93
          cropper: {
94
            instance: resolveModuleDefault(cropperModule),
95
          },
96
          screenfull: {
97
            instance: resolveModuleDefault(screenfullModule),
98
          },
99
        },
100
      })
101
    })()
102
  }
103

104
  return mdEditorRuntimePromise
105
}
106

107
// 创建一个预填参数的mdeditor组件
108
function createWorkOrderMarkdownComponent(component: Component, name: string) {
109
  return defineComponent({
110
    name,
111
    inheritAttrs: false,
112
    setup(_, { attrs, slots }) {
113
      return () =>
114
        h(
115
          component,
116
          {
117
            ...attrs,
118
            noEcharts: true,
119
            sanitize: sanitizeMarkdownHtml,
120
            sanitizeMermaid: sanitizeMarkdownMermaid,
121
          },
122
          slots,
123
        )
124
    },
125
  })
126
}
127

128

129
export async function loadMdEditor() {
130
  await Promise.all([ensureMdEditorRuntime(), import('md-editor-v3/lib/style.css')])
131
  const { default: MdEditor } = await import('md-editor-v3/lib/es/MdEditor.mjs')
132
  return createWorkOrderMarkdownComponent(MdEditor, 'WorkOrderMdEditor')
133
}
134

135
export async function loadMdPreview() {
136
  await Promise.all([ensureMdPreviewRuntime(), import('md-editor-v3/lib/preview.css')])
137
  const { default: MdPreview } = await import('md-editor-v3/lib/es/MdPreview.mjs')
138
  return createWorkOrderMarkdownComponent(MdPreview, 'WorkOrderMdPreview')
139
}

1
import type { CspViolationPayload, ObservabilityConfig } from '../types'
2
import { getCurrentTraceContext } from '../otel/tracer'
3
import { getSessionId, getSessionUrl, trackEvent } from '../replay/openreplay'
4
import { sendCspViolationReport } from '../transports/security-report-transport'
5
import { createCspViolationAntiStorm, type CspAntiStormMetadata } from './csp-violation-anti-storm'
6

7
// 防止重复初始化
8
let isInitialized = false
9
// 保存传入的观测配置，在 violation 事件处理时使用
10
let config: ObservabilityConfig | null = null
11

12
// 去重时间窗口：60 秒内相同指纹的违规只上报少量详情，其余聚合为摘要
210 collapsed lines
13
const CSP_DEDUPE_WINDOW_MS = 60_000
14
// 每个窗口期内允许上报的最多详细报告数（超过数目的将聚合）
15
const CSP_MAX_DETAILED_REPORTS_PER_WINDOW = 3
16
// 最多记录的指纹数量（防止内存无限增长）
17
const CSP_MAX_FINGERPRINTS = 100
18

19
// 创建反风暴实例，用于去重、限流、聚合
20
const antiStorm = createCspViolationAntiStorm({
21
  windowMs: CSP_DEDUPE_WINDOW_MS,
22
  maxDetailedReportsPerWindow: CSP_MAX_DETAILED_REPORTS_PER_WINDOW,
23
  maxFingerprints: CSP_MAX_FINGERPRINTS,
24
})
25

26
// 定时器handle，用于周期性刷新聚合的摘要报告
27
let summaryFlushTimer: number | null = null
28

29
/** 清除定时器，通常在页面卸载或手动 flush 时调用 */
30
function clearSummaryFlushTimer() {
31
  if (!summaryFlushTimer || typeof window === 'undefined') {
32
    return
33
  }
34
  window.clearTimeout(summaryFlushTimer)
35
  summaryFlushTimer = null
36
}
37

38
/**
39
 * 发送一条完整的 CSP 违规报告（详细或聚合摘要）。
40
 * 将防抖节流的Metadata（如指纹、计数）合并到 payload 中一并上报。
41
 */
42
function sendPayload(payload: CspViolationPayload, metadata: CspAntiStormMetadata) {
43
  if (!config) {
44
    return
45
  }
46
  void sendCspViolationReport({ ...payload, ...metadata }, config)
47
}
48
/**
49
 * 强制将所有当前窗口内累积的聚合摘要立即发送。
50
 * @param includeOpenWindow - 是否包含尚未结束的窗口（页面卸载时应为 true）
51
 */
52
function flushCspDuplicateSummaries(includeOpenWindow = false) {
53
  if (!config || typeof window === 'undefined') {
54
    return
55
  }
56
  const observedAt = Date.now()
57
  const summaries = antiStorm.flush(observedAt, { includeOpenWindow })
58
  for (const summary of summaries) {
59
    // 摘要中已经包含 exemplar（代表该指纹的典型违规）和元数据
60
    const { exemplar, ...metadata } = summary
61
    void sendCspViolationReport(
62
      {
63
        // 从典型违规中获取大部分字段
64
        ...exemplar,
65
        channel: 'securitypolicyviolation',
66
        observedAt,
67
        route: exemplar.route ?? window.location.pathname,
68
        release: config.serviceRelease,
69
        serviceName: config.serviceName,
70
        serviceVersion: config.serviceVersion,
71
        environment: config.environment,
72
        userAgent: navigator.userAgent,
73
        language: navigator.language,
74
        // 附加摘要特有的元数据（如次数、首个/末次时间等）
75
        ...metadata,
76
      },
77
      config,
78
    )
79
  }
80
}
81
/** 调度一个定时器，在窗口时间后自动发送聚合摘要 */
82
function scheduleSummaryFlush() {
83
  if (summaryFlushTimer || typeof window === 'undefined') {
84
    return
85
  }
86
  summaryFlushTimer = window.setTimeout(() => {
87
    summaryFlushTimer = null
88
    flushCspDuplicateSummaries()
89
  }, CSP_DEDUPE_WINDOW_MS)
90
}
91
/** 页面卸载时立即发送所有未处理的聚合摘要，并取消定时器 */
92
function flushOpenSummaries() {
93
  clearSummaryFlushTimer()
94
  flushCspDuplicateSummaries(true)
95
}
96

97

98
/**
99
 * CSP 违规事件处理函数。
100
 * 当浏览器触发 `securitypolicyviolation` 事件时，收集所有相关字段，
101
 * 构造上报 payload，分别通过：
102
 * 1. 反风暴模块判断发送详情还是聚合摘要
103
 * 2. 会话回放/埋点工具（trackEvent）
104
 * 进行记录。
105
 */
106
const handleViolation = (event: Event) => {
107
  if (!config) {
108
    return
109
  }
110

111
  const violation = event as SecurityPolicyViolationEvent
112

113
  const traceContext = getCurrentTraceContext()
114
  const sessionId = getSessionId()
115
  const sessionUrl = getSessionUrl()
116
  const observedAt = Date.now()
117

118
  // 构造统一上报的数据结构
119
  const payload: CspViolationPayload = {
120
    // 标记事件渠道，便于后端识别
121
    channel: 'securitypolicyviolation' as const,
122
    // CSP 中被阻止的资源 URL
123
    blockedUri: violation.blockedURI || undefined,
124
    // 违规代码所在列号（如有）
125
    columnNumber: violation.columnNumber || undefined,
126
    // 处置方式：enforce（拦截） 或 report（仅报告）
127
    disposition: violation.disposition,
128
    // 触发违规的页面 URL
129
    documentUri: violation.documentURI || window.location.href,
130
    // 实际生效的 CSP 指令
131
    effectiveDirective: violation.effectiveDirective,
132
    // 违规代码行号（如有）
133
    lineNumber: violation.lineNumber || undefined,
134
    // 本次请求生效的完整 CSP 策略字符串
135
    originalPolicy: violation.originalPolicy,
136
    // 页面来源（Referrer）
137
    referrer: document.referrer || undefined,
138
    // 当前路由路径
139
    route: window.location.pathname,
140
    // CSP 报告中的代码样本（如有）
141
    sample: violation.sample || undefined,
142
    // 用户会话 ID
143
    sessionId: sessionId || undefined,
144
    // 会话回放链接（如有）
145
    sessionUrl: sessionUrl || undefined,
146
    // 服务名称（来自配置）
147
    serviceName: config.serviceName,
148
    // 服务版本
149
    serviceVersion: config.serviceVersion,
150
    // 违规脚本所在的源文件 URL（如有）
151
    sourceFile: violation.sourceFile || undefined,
152
    // 当前 OpenTelemetry span ID
153
    spanId: traceContext.spanId,
154
    // HTTP 状态码（如资源加载失败时的状态码）
155
    statusCode: violation.statusCode || undefined,
156
    // 当前 OpenTelemetry trace ID
157
    traceId: traceContext.traceId,
158
    // 被违反的 CSP 指令（如 script-src）
159
    violatedDirective: violation.violatedDirective,
160
    // 事件发生的客户端时间戳
161
    observedAt,
162
    // 以下为部署相关元数据，用于区分不同环境/版本
163
    release: config.serviceRelease,
164
    gitCommit: config.gitCommit,
165
    gitBranch: config.gitBranch,
166
    buildId: config.buildId,
167
    releaseChannel: config.releaseChannel,
168
    environment: config.environment,
169
    // 客户端信息，方便排查浏览器兼容性
170
    userAgent: navigator.userAgent,
171
    language: navigator.language,
172
    viewport: {
173
      width: window.innerWidth,
174
      height: window.innerHeight,
175
    },
176
  }
177
  const antiStormResult = antiStorm.record(payload, observedAt)
178
  if (antiStormResult.decision === 'send-detail') {
179
    sendPayload(payload, antiStormResult.metadata)
180
  } else {
181
    scheduleSummaryFlush()
182
  }
183

184
  // 同时往会话回放/埋点工具记录一个简化事件，方便在回放中标注 CSP 违规时刻
185
  trackEvent('csp_violation', {
186
    blockedUri: payload.blockedUri,
187
    disposition: payload.disposition,
188
    effectiveDirective: payload.effectiveDirective,
189
    violatedDirective: payload.violatedDirective,
190
  })
191
}
192

193
/**
194
* CSP violations采集器。
195
* 通过监听全局 `securitypolicyviolation` 事件，自动收集并上报 CSP 违规信息。
196
* 需要在使用前调用 `init`，在不需要时调用 `destroy` 移除监听。
197
*/
198
export const securityPolicyCollector = {
199
  init(nextConfig: ObservabilityConfig): void {
200
    if (isInitialized || typeof window === 'undefined') {
201
      return
202
    }
203

204
    config = nextConfig
205
    window.addEventListener('securitypolicyviolation', handleViolation)
206
    window.addEventListener('pagehide', flushOpenSummaries)
207
    isInitialized = true
208
  },
209

210
  destroy(): void {
211
    if (!isInitialized || typeof window === 'undefined') {
212
      return
213
    }
214

215
    window.removeEventListener('securitypolicyviolation', handleViolation)
216
    window.removeEventListener('pagehide', flushOpenSummaries)
217
    flushOpenSummaries()
218
    antiStorm.reset()
219
    isInitialized = false
220
    config = null
221
  },
222
}