amendments-widget

1import { atom, read, update } from 'claude-code'
2import type { Elements, EngineInterface, PluginState, PromptComposeInput, PromptComposeResult, Register, RenderElement, RenderSurface } from 'claude-code'
3import type { WidgetsPlace } from 'widgets'
4
5import { fit, plural, span } from './lib'
6
7type Tags = Pick<Elements[RenderSurface], 'Box' | 'Text'>
8type Held = PluginState['amendments-widget']['held']
9type Report = PluginState['amendments-widget']['report']
10type Row = Report['rows'][number]
11type Texts = Readonly<Record<string, string>>
12type Shot = { version: string; at: number; texts: Record<string, string> }
13type Book = { now: Shot; before: Shot | null; loose: string[] }
14type Shelf = { last: string; books: Record<string, Book> }
15type Edit = { mark: ' ' | '-' | '+'; text: string }
16type Line = { key: string; text: string; isDim: boolean }
17
18const PANE = 'widgets'
19const CARD_COLUMNS = 40
20const CARD_FRAME = 4
21const WIDE_COLUMNS = 30
22const MAX_ROWS = 6
23const MAX_BOOKS = 4
24const MAX_CELLS = 250_000
25const MAX_LINES = 200
26const CONTEXT = 2
27const FILE = 'amendments.json'
28const USAGE = 'Usage: /amendments-widget [on|off|show [n]|clear]'
29const VERBS = ['', 'on', 'off', 'show', 'clear']
30const WHOLE = /^0*([1-9]\d{0,5})$/
31const SECONDS = /^\d+s$/
32const OPENERS = ['intro', 'lean_body', 'bare']
33const EMPTY = 'No baseline yet. After your next turn what Claude Code tells Claude is saved, and each update is compared with it.'
34const AGAIN = '/amendments-widget clear starts again.'
35const FAULTS = { read: 'The snapshot file could not be read.', write: 'The snapshot file could not be written.' } as const
36const NOTES = { none: undefined, new: 'new', baseline: 'baseline', same: 'unchanged', changed: undefined, fault: 'error' } as const
37const COMPARED = 'Compared: shared sections and built-in tool descriptions as the engine wrote them, against the version last run here.'
38const CLEARED = 'Amendments cleared. A new baseline is taken at your next turn.'
39const REST_HELD: Held = { key: '', texts: {} }
40const REST_REPORT: Report = { kind: 'none', version: '', since: '', age: '', sections: 0, tools: 0, rows: [], fault: '' }
41const site = { plugin: 'widgets', key: 'site' } as const
42const widths = { plugin: 'widgets', key: 'widths' } as const
43const isOn = atom({ plugin: 'amendments-widget', key: 'isOn' } as const, false)
44const held = atom({ plugin: 'amendments-widget', key: 'held' } as const, REST_HELD)
45const report = atom({ plugin: 'amendments-widget', key: 'report' } as const, REST_REPORT)
46
47const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value)
48
49const isShot = (value: unknown): value is Shot =>
50  isRecord(value) &&
51  typeof value.version === 'string' &&
52  typeof value.at === 'number' &&
53  isRecord(value.texts) &&
54  Object.values(value.texts).every(text => typeof text === 'string')
55
56const isBook = (value: unknown): value is Book =>
57  isRecord(value) &&
58  isShot(value.now) &&
59  (value.before === null || isShot(value.before)) &&
60  Array.isArray(value.loose) &&
61  value.loose.every(id => typeof id === 'string')
62
63const isShelf = (value: unknown): value is Shelf =>
64  isRecord(value) && typeof value.last === 'string' && isRecord(value.books) && Object.values(value.books).every(isBook)
65
66const cut = (text: string, room: number): string => {
67  const letters = [...text]
68
69  return letters.length <= room ? text : `${letters.slice(0, Math.max(0, room - 1)).join('')}…`
70}
71
72const isSection = (id: string): boolean => id.startsWith('s/')
73
74const labelled = (id: string): string => (isSection(id) ? id.slice(2) : `${id.slice(2)} tool`)
75
76const counted = (texts: Texts): string =>
77  `${plural(Object.keys(texts).filter(isSection).length, 'section')}, ${plural(Object.keys(texts).filter(id => !isSection(id)).length, 'tool')}`
78
79const lines = (text: string | undefined): string[] => (text === undefined || text === '' ? [] : text.split('\n'))
80
81const marked = (texts: readonly string[], mark: Edit['mark']): Edit[] => texts.map(text => ({ mark, text }))
82
83const middle = (old: readonly string[], fresh: readonly string[]): Edit[] => {
84  if (old.length * fresh.length > MAX_CELLS) return [...marked(old, '-'), ...marked(fresh, '+')]
85
86  const wide = fresh.length + 1
87  const table = new Uint16Array((old.length + 1) * wide)
88  for (let row = old.length - 1; row >= 0; row -= 1) {
89    for (let column = fresh.length - 1; column >= 0; column -= 1) {
90      table[row * wide + column] =
91        old[row] === fresh[column]
92          ? (table[(row + 1) * wide + column + 1] ?? 0) + 1
93          : Math.max(table[(row + 1) * wide + column] ?? 0, table[row * wide + column + 1] ?? 0)
94    }
95  }
96
97  const edits: Edit[] = []
98  let row = 0
99  let column = 0
100  while (row < old.length && column < fresh.length) {
101    if (old[row] === fresh[column]) {
102      edits.push({ mark: ' ', text: old[row] ?? '' })
103      row += 1
104      column += 1
105    } else if ((table[(row + 1) * wide + column] ?? 0) >= (table[row * wide + column + 1] ?? 0)) {
106      edits.push({ mark: '-', text: old[row] ?? '' })
107      row += 1
108    } else {
109      edits.push({ mark: '+', text: fresh[column] ?? '' })
110      column += 1
111    }
112  }
113
114  return [...edits, ...marked(old.slice(row), '-'), ...marked(fresh.slice(column), '+')]
115}
116
117const diff = (before: readonly string[], after: readonly string[]): Edit[] => {
118  const short = Math.min(before.length, after.length)
119  let head = 0
120  while (head < short && before[head] === after[head]) head += 1
121  let tail = 0
122  while (tail < short - head && before[before.length - 1 - tail] === after[after.length - 1 - tail]) tail += 1
123
124  return [
125    ...marked(before.slice(0, head), ' '),
126    ...middle(before.slice(head, before.length - tail), after.slice(head, after.length - tail)),
127    ...marked(before.slice(before.length - tail), ' '),
128  ]
129}
130
131const tally = (edits: readonly Edit[]): string =>
132  `+${edits.filter(edit => edit.mark === '+').length} -${edits.filter(edit => edit.mark === '-').length}`
133
134const excerpt = (edits: readonly Edit[]): string[] => {
135  const isShown = edits.map((_, at) => edits.slice(Math.max(0, at - CONTEXT), at + CONTEXT + 1).some(edit => edit.mark !== ' '))
136  const printed: string[] = []
137  edits.forEach((edit, at) => {
138    if (isShown[at] !== true) return
139    if (printed.length > 0 && isShown[at - 1] !== true) printed.push('…')
140    printed.push(`${edit.mark} ${edit.text}`)
141  })
142
143  return printed
144}
145
146const fact = (id: string, before: string | undefined, now: string | undefined): string => {
147  if (before === now) return ''
148  if (before === undefined || now === undefined) return isSection(id) ? (before === undefined ? 'new' : 'dropped') : ''
149
150  return tally(diff(lines(before), lines(now)))
151}
152
153const amended = (book: Book): Row[] => {
154  const before = book.before?.texts
155  if (before === undefined) return []
156
157  return [...new Set([...Object.keys(book.now.texts), ...Object.keys(before)])]
158    .filter(id => !book.loose.includes(id))
159    .sort()
160    .map(id => ({ id, label: labelled(id), fact: fact(id, before[id], book.now.texts[id]) }))
161    .filter(row => row.fact !== '')
162}
163
164const reported = (book: Book | undefined, at: number, running: string): Report => {
165  if (book === undefined) return REST_REPORT
166  if (running !== '' && running !== book.now.version) return { ...REST_REPORT, kind: 'new', version: running, since: book.now.version }
167
168  const keys = Object.keys(book.now.texts)
169  const sections = keys.filter(isSection).length
170  const based = { ...REST_REPORT, version: book.now.version, sections, tools: keys.length - sections }
171  if (book.before === null) return { ...based, kind: 'baseline' }
172
173  const rows = amended(book)
174
175  return { ...based, kind: rows.length === 0 ? 'same' : 'changed', since: book.before.version, age: span(at - book.now.at), rows }
176}
177
178const merged = (book: Book | undefined, texts: Texts, version: string, at: number): Book | undefined => {
179  if (book === undefined) return { now: { version, at, texts: { ...texts } }, before: null, loose: [] }
180
181  const isSided = Object.keys(texts).some(isSection)
182  if (book.now.version !== version) {
183    return isSided
184      ? { now: { version, at, texts: { ...texts } }, before: book.now, loose: book.loose.filter(id => id in texts || id in book.now.texts) }
185      : undefined
186  }
187
188  const kept = { ...book.now.texts }
189  const loose = new Set(book.loose)
190  for (const [id, text] of Object.entries(texts)) {
191    if (kept[id] === undefined && !isSection(id)) kept[id] = text
192    else if (kept[id] !== text) loose.add(id)
193  }
194  if (isSided) for (const id of Object.keys(kept)) if (isSection(id) && texts[id] === undefined) loose.add(id)
195
196  return { now: { ...book.now, texts: kept }, before: book.before, loose: [...loose] }
197}
198
199const pruned = (books: Record<string, Book>): Record<string, Book> =>
200  Object.keys(books).length <= MAX_BOOKS
201    ? books
202    : Object.fromEntries(
203        Object.entries(books)
204          .sort(([, one], [, other]) => other.now.at - one.now.at)
205          .slice(0, MAX_BOOKS),
206      )
207
208const keyed = (e: PromptComposeInput): string => [e.promptModel, [...e.traits].sort().join('+'), e.outputStyle?.name ?? ''].join('|')
209
210const sectioned = (answer: PromptComposeResult): Record<string, string> | undefined =>
211  OPENERS.includes(answer.sections[0]?.id ?? '')
212    ? Object.fromEntries(
213        answer.sections
214          .filter(section => section.scope === 'shared' && !section.id.includes(':') && typeof section.text === 'string')
215          .map(section => [`s/${section.id}`, section.text]),
216      )
217    : undefined
218
219const own = <Answer,>(trace: readonly { plugin: string; returned: Answer | undefined }[] | undefined, answer: Answer): Answer => {
220  const links: readonly { plugin: string; returned: Answer | undefined }[] = Array.isArray(trace) ? trace : []
221
222  return links.find(link => link.plugin === 'engine')?.returned ?? answer
223}
224
225const wrapped = (text: string, room: number): string => {
226  const rows: string[] = []
227  let row: string[] = []
228  for (const word of text.split(' ')) {
229    let letters = [...word]
230    if (row.length > 0 && row.length + 1 + letters.length <= room) {
231      row = [...row, ' ', ...letters]
232      continue
233    }
234    if (row.length > 0) rows.push(row.join(''))
235    while (letters.length > room) {
236      rows.push(letters.slice(0, room).join(''))
237      letters = letters.slice(room)
238    }
239    row = letters
240  }
241
242  return [...rows, row.join('')].join('\n')
243}
244
245const versions = (before: string, now: string, room: number): string => {
246  const spaced = `${before} → ${now}`
247  if (spaced.length <= room) return spaced
248
249  const left = room - now.length - 1
250  const half = Math.floor((room - 1) / 2)
251
252  return left >= 2 ? `${cut(before, left)}→${now}` : `${cut(before, half)}→${cut(now, room - 1 - Math.min(half, before.length))}`
253}
254
255const line = (key: string, text: string, isDim = false): Line => ({ key, text, isDim })
256
257const written = ({ kind, version, since, age, sections, tools, rows, fault }: Report, isWide: boolean, inner: number): Line[] => {
258  const count = line('count', `${plural(sections, 'section')}, ${plural(tools, 'tool')}`)
259  if (kind === 'none') return [line('empty', EMPTY, true)]
260  if (kind === 'fault') return [line('said', FAULTS[fault === 'write' ? 'write' : 'read']), line('next', isWide ? AGAIN : 'clear starts again.')]
261  if (kind === 'new') return [line('said', `${version} is new here (was ${since}).`), line('next', 'Compared after your next turn.')]
262  if (kind === 'baseline') return [count, line('said', `Baseline taken at ${version}. The next update is compared with it.`)]
263  if (kind === 'same') return [count, line('said', `No change since ${since}.`), line('age', SECONDS.test(age) ? `${version} here since just now` : `${version} here for ${age}`, true)]
264
265  const folded = rows.length - MAX_ROWS
266
267  return [
268    ...(folded > 0 ? [line('more', cut(isWide ? `… ${folded} more in show` : `… ${folded} more`, inner), true)] : []),
269    line('versions', versions(since, version, inner), true),
270    line('hint', isWide ? 'show <n>: before and after' : 'show <n>', true),
271  ]
272}
273
274const opened = async ($: EngineInterface): Promise<Shelf | null> => {
275  const path = `${$.plugin.root}/${FILE}`
276  if (!(await $.fs.exists(path))) return { last: '', books: {} }
277
278  try {
279    const parsed: unknown = JSON.parse(await $.fs.read(path))
280
281    return isShelf(parsed) ? parsed : null
282  } catch {
283    return null
284  }
285}
286
287const faulted = async ($: EngineInterface, fault: 'read' | 'write'): Promise<string> => {
288  await update($, report, (): Report => ({ ...REST_REPORT, kind: 'fault', fault }))
289
290  return `${FAULTS[fault]} ${AGAIN}`
291}
292
293const look = async ($: EngineInterface): Promise<void> => {
294  try {
295    const { version } = await $.session.version()
296    const shelf = await opened($)
297    if (shelf === null) {
298      await faulted($, 'read')
299
300      return
301    }
302
303    const book = shelf.books[(await read($, held)).key || shelf.last]
304    const at = await $.clock.now()
305    await update($, report, () => reported(book, at, version))
306  } catch {
307    await update($, report, () => REST_REPORT)
308  }
309}
310
311const flush = async ($: EngineInterface): Promise<void> => {
312  const { key, texts } = await read($, held)
313  if (key === '' || Object.keys(texts).length === 0) return
314
315  try {
316    const { version } = await $.session.version()
317    const at = await $.clock.now()
318    const shelf = await opened($)
319    if (shelf === null) {
320      await faulted($, 'read')
321
322      return
323    }
324
325    const book = merged(shelf.books[key], texts, version, at)
326    const made: Shelf = { last: key, books: pruned(book === undefined ? shelf.books : { ...shelf.books, [key]: book }) }
327    const text = JSON.stringify(made)
328    if (text !== JSON.stringify(shelf)) {
329      try {
330        await $.fs.write(`${$.plugin.root}/${FILE}`, text)
331      } catch {
332        await faulted($, 'write')
333
334        return
335      }
336    }
337
338    await update($, held, kept => ({
339      key: kept?.key ?? key,
340      texts: Object.fromEntries(Object.entries(kept?.texts ?? {}).filter(([id, later]) => texts[id] !== later)),
341    }))
342    await update($, report, () => reported(made.books[key], at, ''))
343  } catch {
344    // A flush that cannot run keeps what is held for the next turn.
345  }
346}
347
348const wipe = async ($: EngineInterface): Promise<string> => {
349  await update($, held, () => REST_HELD)
350  try {
351    await $.fs.write(`${$.plugin.root}/${FILE}`, JSON.stringify({ last: '', books: {} } satisfies Shelf))
352  } catch {
353    return faulted($, 'write')
354  }
355  await update($, report, () => REST_REPORT)
356
357  return CLEARED
358}
359
360const detailed = (book: Book, rows: readonly Row[], wanted: number): string => {
361  const row = rows[wanted - 1]
362  if (row === undefined || book.before === null) return `No amendment ${wanted}. There are ${rows.length}.`
363
364  const printed = excerpt(diff(lines(book.before.texts[row.id]), lines(book.now.texts[row.id])))
365  const left = printed.length - MAX_LINES
366
367  return [
368    `${wanted} ${row.label}: ${row.fact}, ${book.before.version} → ${book.now.version}`,
369    ...printed.slice(0, MAX_LINES),
370    ...(left > 0 ? [`… ${plural(left, 'more line')}`] : []),
371  ].join('\n')
372}
373
374const told = async ($: EngineInterface, wanted: number): Promise<string> => {
375  const shelf = await opened($)
376  if (shelf === null) return `${FAULTS.read} ${AGAIN}`
377
378  const key = (await read($, held)).key || shelf.last
379  const book = shelf.books[key]
380  if (book === undefined) return 'No baseline yet.'
381
382  const rows = amended(book)
383  if (wanted > 0) return detailed(book, rows, wanted)
384  if (book.before === null) return `Baseline taken at ${book.now.version}: ${counted(book.now.texts)}. Nothing to compare yet.`
385
386  const name = key.replace(/\|+$/, '')
387
388  return [
389    rows.length === 0
390      ? `No change since ${book.before.version} (${name}).`
391      : `${book.before.version} → ${book.now.version} (${name}): ${plural(rows.length, 'amendment')}`,
392    ...rows.map((row, at) => `${at + 1}  ${row.label}  ${row.fact}`),
393    ...(book.loose.length === 0 ? [] : [`Left out, varies within one build: ${[...book.loose].sort().map(labelled).join(', ')}`]),
394    COMPARED,
395  ].join('\n')
396}
397
398const show = async (
399  $: EngineInterface,
400  { Box, Text }: Tags,
401  beneath: RenderElement,
402  place: WidgetsPlace,
403  columns: number,
404): Promise<RenderElement> => {
405  if (!(await read($, isOn))) return beneath
406  if ((await $.state.get(site)).value !== place) return beneath
407
408  const width = fit((await $.state.get(widths)).value?.['amendments-widget'] ?? CARD_COLUMNS, columns)
409  const inner = width - CARD_FRAME
410  const isWide = width >= WIDE_COLUMNS
411  const drawn = await read($, report)
412  const rows = drawn.kind === 'changed' ? drawn.rows : []
413  const note = drawn.kind !== 'changed' ? (isWide ? NOTES[drawn.kind] : undefined) : isWide ? plural(rows.length, 'amendment') : String(rows.length)
414
415  return $.widgets.card({
416    beneath,
417    width,
418    title: 'Amendments',
419    ...(note === undefined ? {} : { note }),
420    body: (
421      <Box flexDirection="column">
422        {rows.slice(0, MAX_ROWS).map((row, at) => (
423          <Box key={`row:${at + 1}`} justifyContent="space-between">
424            <Box key={`label:${at + 1}`}>
425              <Text wrap="truncate-end">{cut(`${at + 1} ${row.label}`, inner - row.fact.length - 1)}</Text>
426            </Box>
427            <Box key={`fact:${at + 1}`} flexShrink={0}>
428              <Text dimColor>{row.fact}</Text>
429            </Box>
430          </Box>
431        ))}
432        {written(drawn, isWide, inner).map(({ key, text, isDim }) => (
433          <Box key={key}>
434            <Text dimColor={isDim}>{wrapped(text, inner)}</Text>
435          </Box>
436        ))}
437      </Box>
438    ),
439  })
440}
441
442export const register: Register = on => {
443  on('session.start', async ($, e, next) => {
444    await $.command.register({
445      name: 'amendments-widget',
446      description: 'Toggle the Amendments card, show what changed or clear its snapshots',
447      argumentHint: '[on|off|show [n]|clear]',
448    })
449    if ((await $.store.get('isOn')) === true) {
450      await update($, isOn, () => true)
451      await look($)
452    }
453
454    return next(e)
455  })
456
457  on('command.run', { command: 'amendments-widget' }, async ($, e) => {
458    const [verb = '', ...rest] = e.args.trim().split(/\s+/)
459    const arg = verb.toLowerCase()
460    const wanted = arg === 'show' && rest.length === 1 ? Number(WHOLE.exec(rest[0] ?? '')?.[1] ?? 0) : 0
461    if (!VERBS.includes(arg) || rest.length > (arg === 'show' ? 1 : 0) || (rest.length === 1 && wanted === 0)) return { text: USAGE }
462
463    if (arg === 'show' || arg === 'clear') {
464      if (!(await read($, isOn))) return { text: 'Amendments is off.' }
465
466      return { text: arg === 'clear' ? await wipe($) : await told($, wanted) }
467    }
468
469    const isShown = await update($, isOn, shown => (arg === '' ? !(shown ?? false) : arg === 'on'))
470    await $.store.set('isOn', isShown)
471    if (isShown) await look($)
472    else {
473      await update($, held, () => REST_HELD)
474      await update($, report, () => REST_REPORT)
475    }
476
477    return { text: isShown ? 'Amendments on; /widgets places it.' : 'Amendments off.' }
478  })
479
480  on('prompt.compose', async ($, e, next) => {
481    if (!(await read($, isOn))) return next(e)
482
483    const answer = await next(e)
484    try {
485      if (e.traits.includes('teammate') || e.traits.includes('analysis') || (await read($, held)).key !== '') return answer
486
487      const sections = sectioned(own(next.trace, answer))
488      if (sections !== undefined) {
489        const key = keyed(e)
490        await update($, held, kept => ((kept?.key ?? '') === '' ? { key, texts: { ...kept?.texts, ...sections } } : (kept ?? REST_HELD)))
491      }
492    } catch {
493      // A capture that fails must not cost Claude the prompt it was given.
494    }
495
496    return answer
497  })
498
499  on('tool.describe', async ($, e, next) => {
500    if (!(await read($, isOn))) return next(e)
501
502    const answer = await next(e)
503    try {
504      const text = own(next.trace, answer).description
505      if (e.provider.plugin === 'engine' && typeof text === 'string') {
506        await update($, held, kept => ({ key: kept?.key ?? '', texts: { ...kept?.texts, [`t/${e.tool}`]: text } }))
507      }
508    } catch {
509      // A capture that fails must not cost Claude the description it was given.
510    }
511
512    return answer
513  })
514
515  on('turn.complete', async ($, e, next) => {
516    if (await read($, isOn)) await flush($)
517
518    return next(e)
519  })
520
521  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e, next) =>
522    show($, $.ui.resolve(e), await next(e), 'side', e.props.bodyColumns),
523  )
524
525  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) =>
526    e.props.hasSurvey ? next(e) : show($, $.ui.resolve(e), await next(e), 'above', e.props.bodyColumns),
527  )
528
529  on('ui.render', { component: 'PromptHint' }, async ($, e, next) =>
530    show($, $.ui.resolve(e), await next(e), 'below', e.viewport?.columns ?? 80),
531  )
532}
533

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 AmendmentsSwitch = boolean
2
3declare module 'claude-code' {
4  interface PluginState {
5    'amendments-widget': {
6      isOn: AmendmentsSwitch
7      held: {
8        key: string
9        texts: Record<string, string>
10      }
11      report: {
12        kind: 'none' | 'new' | 'baseline' | 'same' | 'changed' | 'fault'
13        version: string
14        since: string
15        age: string
16        sections: number
17        tools: number
18        rows: {
19          id: string
20          label: string
21          fact: string
22        }[]
23        fault: '' | 'read' | 'write'
24      }
25    }
26  }
27}
28