customs-widget

1import { atom, read, update } from 'claude-code'
2import type { Elements, EngineInterface, PluginState, Register, RenderElement, RenderSurface, ToolCheckResult } from 'claude-code'
3import type { WidgetsPlace } from 'widgets'
4
5import { fit, plural } from './lib'
6
7type Tags = Pick<Elements[RenderSurface], 'Box' | 'Text'>
8type Entry = PluginState['customs-widget']['list'][number]
9type Registry = Entry['registry']
10type Found = Pick<Entry, 'kind' | 'fact' | 'line'>
11type Wanted = Pick<Entry, 'key' | 'name' | 'registry'> & { asked: string; isPrivate: boolean }
12type NpmRecord = { time?: { created?: unknown }; 'dist-tags'?: { latest?: unknown } } | null | undefined
13type PypiRecord = { info?: { version?: unknown }; releases?: Record<string, { upload_time_iso_8601?: unknown }[]> } | null | undefined
14
15const PANE = 'widgets'
16const CARD_COLUMNS = 40
17const CARD_FRAME = 4
18const WIDE_COLUMNS = 30
19const TITLE = 'Customs'
20const USAGE = 'Usage: /customs-widget [on|off|show|trust <name>|clear]'
21const EMPTY = 'Nothing checked yet. Each package Claude installs is looked up on npm or PyPI first; a missing or brand new name is held for your yes.'
22const NPM_URL = 'https://registry.npmjs.org'
23const DOWNLOADS_URL = 'https://api.npmjs.org/downloads/point/last-week'
24const PYPI_URL = 'https://pypi.org/pypi'
25const PUBLIC_NPM = '//registry.npmjs.org'
26const LIMIT_MS = 4000
27const DAY_MS = 86_400_000
28const NEW_DAYS = 30
29const MAX_KEYS = 8
30const MAX_LIST = 8
31const MAX_EARLIER = 5
32const MAX_TRUSTED = 100
33const FORMS: Record<Registry, string[]> = {
34  npm: ['npm install', 'npm i', 'npm add', 'pnpm add', 'pnpm install', 'pnpm i', 'yarn add', 'bun add', 'bun install', 'bun i'],
35  pypi: [
36    'pip install',
37    'pip3 install',
38    'python -m pip install',
39    'python3 -m pip install',
40    'py -m pip install',
41    'uv add',
42    'uv pip install',
43  ],
44}
45const VALUE_FLAGS = [
46  '-r -e -c -t -p -w -C -F -i -f --requirement --editable --constraint --constraints --target --prefix --python --filter',
47  '--workspace --cwd --dir --group --extra --optional --package --project --directory --script --marker --tag --branch --rev',
48  '--bounds --python-version --python-platform --platform --implementation --abi --root --src --upgrade-strategy',
49  '--upgrade-package --reinstall-package --no-binary --only-binary --no-binary-package --no-build-package --config-settings',
50  '--config-setting --progress-bar --root-user-action --report --log --timeout --retries --proxy --cert --client-cert',
51  '--trusted-host --exists-action --use-feature --use-deprecated --resolution --prerelease --exclude-newer --index-strategy',
52  '--keyring-provider --link-mode --override --overrides --loglevel --reporter --cache --cache-dir --cache-folder --store-dir',
53  '--modules-dir --modules-folder --userconfig --config --config-file --omit --include --otp --scope --before --save-prefix',
54  '--install-strategy --cpu --os --libc --backend --network-timeout --network-concurrency --mutex --color --registry',
55  '--index-url --extra-index-url --find-links --index --default-index',
56].flatMap(row => row.split(' '))
57const PRIVATE_FLAGS = ['--registry', '--index-url', '-i', '--extra-index-url', '--find-links', '-f', '--index', '--default-index']
58const ARCHIVES = ['.tgz', '.whl', '.gz', '.zip']
59const NPM_NAME = /^(@[a-z0-9._-]+\/)?[a-z0-9][a-z0-9._-]*$/
60const PYPI_NAME = /^([A-Za-z0-9][A-Za-z0-9._-]*)(\[[^\]]*\])?$/
61const BARE_NAME = /^[a-z0-9][a-z0-9._-]*$/
62const WORD = /(?:[^\s'"]|'[^']*'|"[^"]*")+/g
63const QUOTED = /'([^']*)'|"([^"]*)"/g
64const PLAIN_VERSION = /^(\d+)(\.\d+)*(-[\w.]+)?$/
65const REGISTRIES = { npm: 'npm', pypi: 'PyPI' } as const
66const MARKS = {
67  missing: { mark: '✗', color: 'red' },
68  new: { mark: '✗', color: 'red' },
69  behind: { mark: '!', color: 'yellow' },
70  ok: { mark: '✓', color: 'green' },
71  unchecked: { mark: '?', color: undefined },
72  skipped: { mark: '·', color: undefined },
73  checking: { mark: '…', color: undefined },
74} as const
75const SKIPPED: Found = { kind: 'skipped', fact: 'skipped', line: 'not looked up: private scope or registry' }
76const NONE: Entry[] = []
77const NO_NAMES: string[] = []
78const site = { plugin: 'widgets', key: 'site' } as const
79const widths = { plugin: 'widgets', key: 'widths' } as const
80const isOn = atom({ plugin: 'customs-widget', key: 'isOn' } as const, false)
81const list = atom({ plugin: 'customs-widget', key: 'list' } as const, NONE)
82const trusted = atom({ plugin: 'customs-widget', key: 'trusted' } as const, NO_NAMES)
83
84const bare = (name: string): string => name.toLowerCase().replace(/[-_.]+/g, '-')
85
86const cut = (text: string, columns: number): string => (text.length > columns ? `${text.slice(0, Math.max(0, columns - 1))}…` : text)
87
88const wrapped = (text: string, columns: number): string[] =>
89  text
90    .split(' ')
91    .map(word => cut(word, columns))
92    .reduce<string[]>((rows, word) => {
93      const last = rows.at(-1)
94
95      return last !== undefined && last.length + 1 + word.length <= columns ? [...rows.slice(0, -1), `${last} ${word}`] : [...rows, word]
96    }, [])
97
98const age = (days: number): string => {
99  if (days < 60) return plural(days, 'day')
100  if (days < 720) return plural(Math.floor(days / 30), 'month')
101
102  return plural(Math.floor(days / 365), 'year')
103}
104
105const weekly = (downloads: number | undefined): string => {
106  if (downloads === undefined) return ''
107  if (downloads < 1000) return `, ${plural(downloads, 'download')} last week`
108
109  return `, ${downloads < 1_000_000 ? `${Math.floor(downloads / 1000)}k` : `${Math.floor(downloads / 1_000_000)}M`} downloads last week`
110}
111
112const checking = (registry: Registry): Found => ({ kind: 'checking', fact: 'checking', line: `looking up on ${REGISTRIES[registry]}` })
113
114const unchecked = (registry: Registry): Found => ({ kind: 'unchecked', fact: 'unchecked', line: `unchecked: ${REGISTRIES[registry]} did not answer` })
115
116const missing = (item: Wanted): Found => ({ kind: 'missing', fact: 'not found', line: `no package named ${item.name} on ${REGISTRIES[item.registry]}` })
117
118const judged = (item: Wanted, created: number, latest: string, downloads: number | undefined, now: number): Found => {
119  const days = Math.max(0, Math.floor((now - created) / DAY_MS))
120  if (days < NEW_DAYS) return { kind: 'new', fact: age(days), line: `first published ${age(days)} ago${weekly(downloads)}` }
121
122  const asked = PLAIN_VERSION.exec(item.asked)?.[1]
123  const newest = /^\d+/.exec(latest)?.[0]
124  if (asked !== undefined && newest !== undefined && Number(asked) < Number(newest)) {
125    return { kind: 'behind', fact: `${item.asked} → ${latest}`, line: `asked ${item.asked}, latest is ${latest}` }
126  }
127
128  return { kind: 'ok', fact: latest, line: `on ${REGISTRIES[item.registry]} ${age(days)}${weekly(downloads)}, latest ${latest}` }
129}
130
131const isRedirection = (word: string): boolean => /[<>]/.test(word) && !/['"]/.test(word)
132
133const settled = (words: string[]): string[] =>
134  words.slice(0, words.includes('&') ? words.indexOf('&') : words.length).flatMap((word, at, all) => {
135    const before = all[at - 1] ?? ''
136    if (isRedirection(before) && /[<>&]$/.test(before)) return []
137    if (!isRedirection(word)) return [word.replace(QUOTED, '$1$2')]
138
139    const kept = word.slice(0, word.search(/[<>]/))
140
141    return kept === '' || kept === '&' || /^\d+$/.test(kept) ? [] : [kept]
142  })
143
144const uncommented = (row: string): string => {
145  const comment = [...row.matchAll(WORD)].find(word => word[0].startsWith('#'))
146
147  return comment === undefined ? row : row.slice(0, comment.index)
148}
149
150const isLocal = (word: string): boolean =>
151  /^[./~]/.test(word) ||
152  word.includes(':') ||
153  word.includes('\\') ||
154  (word.includes('/') && !word.startsWith('@')) ||
155  ARCHIVES.some(ending => word.endsWith(ending))
156
157const npmName = (word: string, isPrivate: boolean): Wanted | undefined => {
158  const at = word.lastIndexOf('@')
159  const name = at > 0 ? word.slice(0, at) : word
160  if (!NPM_NAME.test(name)) return undefined
161
162  const version = at > 0 ? word.slice(at + 1).replace(/^[\^~=<>v]+/, '') : ''
163
164  return { key: `npm:${name}`, name, registry: 'npm', asked: /^\d/.test(version) ? version : '', isPrivate }
165}
166
167const pypiName = (word: string, isPrivate: boolean): Wanted | undefined => {
168  if (/^[\d.]+$/.test(word)) return undefined
169
170  const at = word.search(/[=<>!~]/)
171  const found = PYPI_NAME.exec(at === -1 ? word : word.slice(0, at))?.[1]
172  if (found === undefined) return undefined
173
174  const name = bare(found)
175  const spec = at === -1 ? '' : word.slice(at)
176
177  return { key: `pypi:${name}`, name, registry: 'pypi', asked: /^==\d/.test(spec) ? spec.slice(2) : '', isPrivate }
178}
179
180const named = (segment: string): Wanted[] => {
181  if (/[$`(]/.test(segment)) return []
182
183  const words = segment.match(WORD) ?? []
184  const first = words.findIndex(word => word !== 'sudo' && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word))
185  const line = (first === -1 ? [] : words.slice(first)).join(' ')
186  const registry = (['npm', 'pypi'] as const).find(kind => FORMS[kind].some(form => line.startsWith(`${form} `)))
187  if (registry === undefined) return []
188
189  const form = FORMS[registry].find(start => line.startsWith(`${start} `)) ?? ''
190  const rest = settled(line.slice(form.length + 1).match(WORD) ?? [])
191  const isPrivate = rest.some(word => PRIVATE_FLAGS.some(flag => word === flag || word.startsWith(`${flag}=`)))
192
193  return rest
194    .filter((word, at) => !word.startsWith('-') && !VALUE_FLAGS.includes(rest[at - 1] ?? '') && !isLocal(word))
195    .flatMap(word => (registry === 'npm' ? npmName(word, isPrivate) : pypiName(word, isPrivate)) ?? [])
196}
197
198const parsed = (command: string): Wanted[] =>
199  command
200    .split('\n')
201    .map(uncommented)
202    .join('\n')
203    .split(/&&|\|\||[;|\n]/)
204    .flatMap(segment => named(segment.trim()))
205    .filter((item, at, all) => all.findIndex(other => other.key === item.key) === at)
206    .slice(0, MAX_KEYS)
207
208const json = (text: string): unknown => {
209  try {
210    return JSON.parse(text)
211  } catch {
212    return undefined
213  }
214}
215
216const moment = (value: unknown): number => (typeof value === 'string' ? Date.parse(value) : Number.NaN)
217
218const downloaded = async ($: EngineInterface, name: string): Promise<number | undefined> => {
219  try {
220    const answer = await $.http.fetch(`${DOWNLOADS_URL}/${name}`)
221    const count = answer.status === 200 ? (json(answer.text) as { downloads?: unknown } | null | undefined)?.downloads : undefined
222
223    return typeof count === 'number' ? count : undefined
224  } catch {
225    return undefined
226  }
227}
228
229const onNpm = async ($: EngineInterface, item: Wanted, now: number): Promise<Found> => {
230  const answer = await $.http.fetch(`${NPM_URL}/${item.name}`)
231  if (answer.status === 404) return missing(item)
232
233  const record = answer.status === 200 ? (json(answer.text) as NpmRecord) : undefined
234  const created = moment(record?.time?.created)
235  const latest = record?.['dist-tags']?.latest
236  if (typeof latest !== 'string' || !Number.isFinite(created)) return unchecked('npm')
237
238  return judged(item, created, latest, await downloaded($, item.name), now)
239}
240
241const onPypi = async ($: EngineInterface, item: Wanted, now: number): Promise<Found> => {
242  const answer = await $.http.fetch(`${PYPI_URL}/${item.name}/json`)
243  if (answer.status === 404) return missing(item)
244
245  const record = answer.status === 200 ? (json(answer.text) as PypiRecord) : undefined
246  const latest = record?.info?.version
247  const created = Math.min(
248    ...Object.values(record?.releases ?? {})
249      .flat()
250      .map(file => moment(file.upload_time_iso_8601))
251      .filter(Number.isFinite),
252  )
253  if (typeof latest !== 'string' || !Number.isFinite(created)) return unchecked('pypi')
254
255  return judged(item, created, latest, undefined, now)
256}
257
258const lookup = async ($: EngineInterface, item: Wanted, now: number): Promise<Found> => {
259  try {
260    return await (item.registry === 'npm' ? onNpm($, item, now) : onPypi($, item, now))
261  } catch {
262    return unchecked(item.registry)
263  }
264}
265
266const timeUp = async ($: EngineInterface, signal: AbortSignal | undefined): Promise<undefined> => {
267  try {
268    await $.clock.sleep(LIMIT_MS, signal === undefined ? {} : { signal })
269  } catch {
270    // The wait rejects when the check ends first; that is not a failure.
271  }
272
273  return undefined
274}
275
276const mirrored = async ($: EngineInterface): Promise<boolean> => {
277  try {
278    const text = await $.fs.read(`${await $.session.cwd()}/.npmrc`)
279
280    return text.split('\n').some(row => /^\s*registry\s*=/.test(row) && !row.includes(PUBLIC_NPM))
281  } catch {
282    return false
283  }
284}
285
286const merged = (fresh: readonly Entry[], held: readonly Entry[]): Entry[] =>
287  [...fresh, ...held.filter(entry => !fresh.some(other => other.key === entry.key))].slice(0, MAX_LIST)
288
289const gate = async (
290  $: EngineInterface,
291  input: unknown,
292  id: string | undefined,
293  verdict: ToolCheckResult,
294  signal: AbortSignal | undefined,
295): Promise<ToolCheckResult> => {
296  const command = (input as { command?: unknown } | null)?.command
297  if (id === undefined || typeof command !== 'string' || verdict.decision === 'deny') return verdict
298
299  const wanted = parsed(command)
300  if (wanted.length === 0) return verdict
301
302  const isMirrored = wanted.some(item => item.registry === 'npm') && (await mirrored($))
303  const isSkipped = (item: Wanted): boolean => item.isPrivate || (item.registry === 'npm' && (isMirrored || item.name.startsWith('@')))
304  const entry = (item: Wanted, found: Found): Entry => ({ key: item.key, name: item.name, registry: item.registry, ...found, held: false })
305  const now = await $.clock.now()
306  await update($, list, held => merged(wanted.map(item => entry(item, isSkipped(item) ? SKIPPED : checking(item.registry))), held ?? []))
307
308  const limit = timeUp($, signal)
309  const found = await Promise.all(
310    wanted.map(async item => (isSkipped(item) ? SKIPPED : ((await Promise.race([lookup($, item, now), limit])) ?? unchecked(item.registry)))),
311  )
312  const names = await read($, trusted)
313  const entries = wanted.map((item, at) => entry(item, found[at] ?? unchecked(item.registry)))
314  const flagged = entries.filter(item => (item.kind === 'missing' || item.kind === 'new') && !names.includes(bare(item.name)))
315  const isRaised = flagged.length > 0 && verdict.decision === 'allow'
316  const isOurs = (item: Entry): boolean => wanted.some(other => other.key === item.key)
317  const kept = await update($, list, (held = []) =>
318    held.some(isOurs) ? merged(entries.map(item => ({ ...item, held: isRaised && flagged.includes(item) })), held) : held,
319  )
320
321  const [first] = flagged
322  if (first === undefined || !kept.some(isOurs)) return verdict
323
324  const line = `${first.name}: ${first.line}${flagged.length > 1 ? ` (+${flagged.length - 1} more)` : ''}`
325  if (isRaised) return { decision: 'ask', reason: line }
326
327  try {
328    await $.ui.notice(id, line)
329  } catch {
330    // A call that is not open refuses the line; the verdict still stands.
331  }
332
333  return verdict
334}
335
336const row = (Text: Tags['Text'], entry: Entry, inner: number, isWide: boolean): RenderElement => {
337  const { mark, color } = MARKS[entry.kind]
338  const room = inner - 3 - entry.fact.length
339  const hasFact = isWide && room >= 3
340  const name = cut(entry.name, hasFact ? room : inner - 2)
341
342  return (
343    <Text wrap="truncate-end" dimColor={color === undefined}>
344      <Text color={color}>{mark}</Text> {name}
345      {hasFact ? `${' '.repeat(inner - 2 - name.length - entry.fact.length)}${entry.fact}` : ''}
346    </Text>
347  )
348}
349
350const show = async (
351  $: EngineInterface,
352  { Box, Text }: Tags,
353  beneath: RenderElement,
354  place: WidgetsPlace,
355  columns: number,
356): Promise<RenderElement> => {
357  if (!(await read($, isOn))) return beneath
358  if ((await $.state.get(site)).value !== place) return beneath
359
360  const width = fit((await $.state.get(widths)).value?.['customs-widget'] ?? CARD_COLUMNS, columns)
361  const entries = await read($, list)
362  const [latest, ...earlier] = entries
363  const inner = width - CARD_FRAME
364  const held = entries.filter(entry => entry.held).length
365  const note = held > 0 ? `${held} held` : plural(entries.length, 'package')
366  const isWide = width >= WIDE_COLUMNS
367
368  return $.widgets.card({
369    beneath,
370    width,
371    title: TITLE,
372    note: latest === undefined ? '' : note.length > inner - TITLE.length - 1 ? `${held > 0 ? held : entries.length}` : note,
373    body: (
374      <Box flexDirection="column">
375        {latest === undefined && wrapped(EMPTY, inner).map(text => <Text dimColor>{text}</Text>)}
376        {latest !== undefined && row(Text,latest, inner, isWide)}
377        {latest !== undefined &&
378          wrapped(latest.line, inner).map(text => (
379            <Text color={MARKS[latest.kind].color} dimColor={MARKS[latest.kind].color === undefined}>
380              {text}
381            </Text>
382          ))}
383        {earlier.slice(0, MAX_EARLIER).map(entry => row(Text,entry, inner, isWide))}
384      </Box>
385    ),
386  })
387}
388
389export const register: Register = on => {
390  on('session.start', async ($, e, next) => {
391    await $.command.register({
392      name: 'customs-widget',
393      description: 'Toggle the Customs card',
394      argumentHint: '[on|off|show|trust <name>|clear]',
395    })
396    if ((await $.store.get('isOn')) === true) await update($, isOn, () => true)
397
398    const names = await $.store.get('trusted')
399    if (Array.isArray(names)) await update($, trusted, () => names.filter(name => typeof name === 'string'))
400
401    return next(e)
402  })
403
404  on('command.run', { command: 'customs-widget' }, async ($, e) => {
405    const arg = e.args.trim().toLowerCase()
406    const [verb, name, ...more] = arg.split(/\s+/)
407    if (verb === 'show' || verb === 'clear' || verb === 'trust') {
408      if (verb === 'trust' ? name === undefined || more.length > 0 || !BARE_NAME.test(name) : name !== undefined) return { text: USAGE }
409      if (!(await read($, isOn))) return { text: 'Customs is off.' }
410
411      const names = await read($, trusted)
412      if (verb === 'show') {
413        const rows = (await read($, list)).map(
414          entry => `${entry.name} (${REGISTRIES[entry.registry]}): ${entry.line}${entry.held ? ' [held]' : ''}`,
415        )
416        const text = [...rows, ...(names.length === 0 ? [] : [`Trusted: ${names.join(', ')}`])].join('\n')
417
418        return { text: text === '' ? 'Nothing checked yet.' : text }
419      }
420
421      const kept = verb === 'clear' ? [] : names.includes(bare(name ?? '')) ? names : [...names, bare(name ?? '')].slice(-MAX_TRUSTED)
422      if (verb === 'clear') await update($, list, () => [])
423      if (kept !== names) {
424        await update($, trusted, () => kept)
425        await $.store.set('trusted', kept)
426      }
427
428      return { text: verb === 'clear' ? 'Customs cleared.' : `Customs trusts ${bare(name ?? '')}.` }
429    }
430    if (arg !== '' && arg !== 'on' && arg !== 'off') return { text: USAGE }
431
432    const isShown = await update($, isOn, shown => (arg === '' ? !(shown ?? false) : arg === 'on'))
433    await $.store.set('isOn', isShown)
434    if (!isShown) await update($, list, () => [])
435
436    return { text: isShown ? 'Customs on; /widgets places it.' : 'Customs off.' }
437  })
438
439  on('tool.check', { tool: 'Bash' }, async ($, e, next) => {
440    if (!(await read($, isOn))) return next(e)
441
442    return gate($, e.input, e.tool_use_id, await next(e), next.signal)
443  })
444
445  on('tool.check', { tool: 'PowerShell' }, async ($, e, next) => {
446    if (!(await read($, isOn))) return next(e)
447
448    return gate($, e.input, e.tool_use_id, await next(e), next.signal)
449  })
450
451  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e, next) =>
452    show($, $.ui.resolve(e), await next(e), 'side', e.props.bodyColumns),
453  )
454
455  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) =>
456    e.props.hasSurvey ? next(e) : show($, $.ui.resolve(e), await next(e), 'above', e.props.bodyColumns),
457  )
458
459  on('ui.render', { component: 'PromptHint' }, async ($, e, next) =>
460    show($, $.ui.resolve(e), await next(e), 'below', e.viewport?.columns ?? 80),
461  )
462}
463

1const MIN_CARD = 20
2const BARS = '▁▂▃▄▅▆▇█'
3
4export const fit = (wanted: number, columns: number): number => Math.min(wanted, Math.max(MIN_CARD, columns))
5
6export const plural = (count: number, word: string): string => `${count} ${word}${count === 1 ? '' : 's'}`
7
8export const span = (ms: number): string => {
9  const seconds = Math.max(0, Math.round(ms / 1000))
10  if (seconds < 60) return `${seconds}s`
11  const minutes = Math.floor(seconds / 60)
12  if (minutes < 60) return `${minutes}m ${String(seconds % 60).padStart(2, '0')}s`
13  const hours = Math.floor(minutes / 60)
14  if (hours < 24) return `${hours}h ${String(minutes % 60).padStart(2, '0')}m`
15
16  return `${Math.floor(hours / 24)}d ${hours % 24}h`
17}
18
19export const spark = (values: readonly number[], width: number): string => {
20  const shown = width > 0 ? values.slice(-width) : []
21  const top = Math.max(...shown, 0)
22
23  return shown
24    .map(value => (top <= 0 ? BARS[0] : BARS[Math.min(BARS.length - 1, Math.round((Math.max(0, value) / top) * (BARS.length - 1)))]))
25    .join('')
26}
27
28export const hash = (text: string): number => {
29  let held = 2166136261
30  for (const letter of text) held = Math.imul(held ^ (letter.codePointAt(0) ?? 0), 16777619)
31
32  return held >>> 0
33}
34
35export const shade = (color: number, factor: number): number =>
36  (Math.round((color >> 16) * factor) << 16) |
37  (Math.round(((color >> 8) & 255) * factor) << 8) |
38  Math.round((color & 255) * factor)
39
40export const folder = (path: string): string => {
41  const flat = path.replaceAll('\\', '/').replace(/\/+$/, '')
42
43  return /^[a-z]:/i.test(flat) ? flat.toLowerCase() : flat
44}
45

1export type CustomsSwitch = boolean
2
3declare module 'claude-code' {
4  interface PluginState {
5    'customs-widget': {
6      isOn: CustomsSwitch
7      list: {
8        key: string
9        name: string
10        registry: 'npm' | 'pypi'
11        kind: 'checking' | 'missing' | 'new' | 'behind' | 'ok' | 'unchecked' | 'skipped'
12        fact: string
13        line: string
14        held: boolean
15      }[]
16      trusted: string[]
17    }
18  }
19}
20