@prestack/thread 0.0.1 → 0.0.2

package/dist/integrity/lsp/findings.ts

@@ -0,0 +1,63 @@
+export interface At {
+  readonly line: number
+  readonly column: number
+  readonly endLine?: number
+  readonly endColumn?: number
+}
+
+export interface Finding {
+  readonly severity: 'error' | 'warning'
+
+  readonly check: string
+  readonly detail: string
+
+  readonly file: string
+
+  readonly at?: At
+
+  readonly anchor?: string
+
+  readonly suggestions?: readonly string[]
+}
+
+export function detailOf(finding: Finding): string {
+  const offered = finding.suggestions ?? []
+  return offered.length === 0 ? finding.detail : `${finding.detail} ${offered.join(' ')}`
+}
+
+const DECLARED_ID = /\b[a-z]{2,6}_[a-z][a-z0-9_]*\b/g
+
+export function anchorIn(detail: string): string | undefined {
+  const candidates = [
+    ...(detail.match(DECLARED_ID) ?? []),
+    ...[...detail.matchAll(/"([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_*]+)+)"/g)].map((m) => m[1] as string),
+  ]
+  if (candidates.length === 0) return undefined
+  return candidates.reduce((longest, one) => (one.length > longest.length ? one : longest))
+}
+
+export function locate(text: string, anchor: string): At | undefined {
+  const lines = text.split('\n')
+  for (const [index, line] of lines.entries()) {
+    const column = line.indexOf(anchor)
+    if (column === -1) continue
+    return {
+      line: index + 1,
+      column: column + 1,
+      endLine: index + 1,
+      endColumn: column + 1 + anchor.length,
+    }
+  }
+  return undefined
+}
+
+export function headOf(text: string): At {
+  const first = text.split('\n')[0] ?? ''
+  return { line: 1, column: 1, endLine: 1, endColumn: Math.max(first.length, 1) + 1 }
+}
+
+export function rangeOf(finding: Finding, text: string): At {
+  if (finding.at !== undefined) return finding.at
+  const anchor = finding.anchor ?? anchorIn(finding.detail)
+  return (anchor === undefined ? undefined : locate(text, anchor)) ?? headOf(text)
+}

package/dist/integrity/lsp/lint.ts

@@ -0,0 +1,140 @@
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { extname, join } from 'node:path'
+
+import { theRules } from '../lint.ts'
+
+import type { Finding } from './findings.ts'
+
+interface EslintMessage {
+  readonly ruleId?: string | null
+  readonly severity: number
+  readonly message: string
+  readonly line?: number
+  readonly column?: number
+  readonly endLine?: number
+  readonly endColumn?: number
+
+  readonly suggestions?: readonly { readonly desc?: string }[]
+}
+
+interface EslintFile {
+  readonly messages?: readonly EslintMessage[]
+}
+
+const LINTABLE = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs', '.jsx'])
+
+export const isLintable = (relative: string): boolean => LINTABLE.has(extname(relative))
+
+export const LINT_CONFIG = 'eslint.config.js'
+
+export class LintUnavailableError extends Error {
+  constructor(detail: string) {
+    super(
+      `ESLint could not be run over this repository: ${detail}. This server reports what the build ` +
+        'computes, so a lint pass that answered "no problems" because it never ran would be ' +
+        'indistinguishable from a clean file — which is the one thing it must never be.',
+    )
+    this.name = 'LintUnavailableError'
+  }
+}
+
+function binaryIn(root: string): string | undefined {
+  const local = join(root, 'node_modules', '.bin', 'eslint')
+  return existsSync(local) ? local : undefined
+}
+
+async function ruleFindings(relative: string, text: string): Promise<readonly Finding[]> {
+  const rules = theRules()
+  return rules(relative, text).map((violation) => ({
+    severity: 'error' as const,
+    check: violation.rule,
+
+    detail: violation.bans ?? violation.message,
+    file: relative,
+    at: { line: violation.line, column: violation.column },
+    suggestions: [
+      ...(violation.instead === undefined ? [] : [violation.instead]),
+      ...(violation.right === undefined ? [] : [`Write: ${violation.right}`]),
+    ],
+  }))
+}
+
+const suggestionsOf = (message: EslintMessage): readonly string[] =>
+  (message.suggestions ?? []).map((one) => one.desc).filter((desc): desc is string => desc !== undefined)
+
+export async function lintFindings(root: string, relative: string, text: string): Promise<readonly Finding[]> {
+  if (!isLintable(relative)) return []
+
+  if (!existsSync(join(root, LINT_CONFIG))) return await ruleFindings(relative, text)
+
+  const binary = binaryIn(root)
+  if (binary === undefined) {
+    return [
+      {
+        severity: 'error',
+        check: 'lint:unavailable',
+        detail:
+          `${LINT_CONFIG} is here and node_modules/.bin/eslint is not, so none of this repository's ` +
+          'rules are being checked while you type. Install the dev dependencies.',
+        file: LINT_CONFIG,
+      },
+    ]
+  }
+
+  const report = await runEslint(binary, root, relative, text)
+
+  return report.flatMap((file) =>
+    (file.messages ?? []).map((message) => ({
+      severity: message.severity === 2 ? ('error' as const) : ('warning' as const),
+      check: message.ruleId ?? 'lint',
+      detail: message.message,
+      file: relative,
+      at: {
+        line: message.line ?? 1,
+        column: message.column ?? 1,
+        ...(message.endLine === undefined ? {} : { endLine: message.endLine }),
+        ...(message.endColumn === undefined ? {} : { endColumn: message.endColumn }),
+      },
+      ...(suggestionsOf(message).length === 0 ? {} : { suggestions: suggestionsOf(message) }),
+    })),
+  )
+}
+
+function runEslint(
+  binary: string,
+  root: string,
+  relative: string,
+  text: string,
+): Promise<readonly EslintFile[]> {
+  return new Promise((resolve, reject) => {
+
+    const child = spawn(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
+      cwd: root,
+      shell: false,
+    })
+
+    let out = ''
+    let err = ''
+    child.stdout.on('data', (chunk: Buffer) => (out += chunk.toString()))
+    child.stderr.on('data', (chunk: Buffer) => (err += chunk.toString()))
+    child.on('error', (error) => reject(new LintUnavailableError(error.message)))
+    child.on('close', () => {
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(out)
+      } catch {
+        reject(new LintUnavailableError(err.trim() === '' ? `it wrote ${out.length} bytes of non-JSON` : err.trim()))
+        return
+      }
+      if (!Array.isArray(parsed)) {
+        reject(new LintUnavailableError('its JSON report was not an array of files'))
+        return
+      }
+      resolve(parsed as readonly EslintFile[])
+    })
+
+    child.stdin.end(text)
+  })
+}

package/dist/integrity/lsp/protocol.ts

@@ -0,0 +1,78 @@
+
+
+export interface RpcMessage {
+  readonly jsonrpc: '2.0'
+  readonly id?: number | string | null
+  readonly method?: string
+  readonly params?: unknown
+  readonly result?: unknown
+  readonly error?: { readonly code: number; readonly message: string }
+}
+
+const HEADER_END = '\r\n\r\n'
+
+export const METHOD_NOT_FOUND = -32601
+
+export function encode(message: RpcMessage): Buffer {
+  const body = Buffer.from(JSON.stringify(message), 'utf8')
+  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}${HEADER_END}`, 'ascii'), body])
+}
+
+export class MalformedMessageError extends Error {
+  constructor(detail: string) {
+    super(
+      `the editor sent something this server cannot parse: ${detail}. ` +
+        'A language server that skipped it would answer the next request against a stream it no ' +
+        'longer understands, which reads as a file with no problems.',
+    )
+    this.name = 'MalformedMessageError'
+  }
+}
+
+export class MessageBuffer {
+  #pending: Buffer = Buffer.alloc(0)
+
+  push(chunk: Buffer): readonly RpcMessage[] {
+    this.#pending = Buffer.concat([this.#pending, chunk])
+
+    const found: RpcMessage[] = []
+    for (;;) {
+      const split = this.#pending.indexOf(HEADER_END, 0, 'ascii')
+      if (split === -1) return found
+
+      const header = this.#pending.subarray(0, split).toString('ascii')
+      const length = contentLength(header)
+      const start = split + HEADER_END.length
+
+      if (this.#pending.length < start + length) return found
+
+      const body = this.#pending.subarray(start, start + length).toString('utf8')
+      this.#pending = this.#pending.subarray(start + length)
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(body)
+      } catch {
+        throw new MalformedMessageError(`a ${length}-byte body that is not JSON`)
+      }
+      if (typeof parsed !== 'object' || parsed === null) {
+        throw new MalformedMessageError(`a ${length}-byte body that is not a JSON object`)
+      }
+      found.push(parsed as RpcMessage)
+    }
+  }
+}
+
+function contentLength(header: string): number {
+  for (const line of header.split('\r\n')) {
+    const [name, value] = line.split(':', 2)
+
+    if (name?.trim().toLowerCase() !== 'content-length') continue
+    const length = Number.parseInt((value ?? '').trim(), 10)
+    if (!Number.isInteger(length) || length < 0) {
+      throw new MalformedMessageError(`Content-Length: ${(value ?? '').trim()}`)
+    }
+    return length
+  }
+  throw new MalformedMessageError(`a header block with no Content-Length: ${JSON.stringify(header)}`)
+}

package/dist/integrity/lsp/server.ts

@@ -0,0 +1,224 @@
+import { relative as relativeTo, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import { named } from '../../core/scope.ts'
+import { report, SOURCE_NAME, type Diagnostic, type DiagnosticSource } from './diagnostics.ts'
+import { METHOD_NOT_FOUND, type RpcMessage } from './protocol.ts'
+
+const SYNC_FULL = 1
+
+export interface ServerOptions {
+
+  readonly root: string
+
+  readonly sourceFor: (root: string) => DiagnosticSource
+  send(message: RpcMessage): void
+
+  settle?(): Promise<void>
+}
+
+interface TextDocumentIdentifier {
+  readonly uri?: unknown
+}
+
+interface DidOpenParams {
+  readonly textDocument?: { readonly uri?: unknown; readonly text?: unknown }
+}
+
+interface DidChangeParams {
+  readonly textDocument?: TextDocumentIdentifier
+  readonly contentChanges?: readonly { readonly text?: unknown }[]
+}
+
+interface InitializeParams {
+  readonly rootUri?: unknown
+  readonly rootPath?: unknown
+  readonly workspaceFolders?: readonly { readonly uri?: unknown }[] | null
+}
+
+export class LspServer {
+  #root: string
+  readonly #options: ServerOptions
+
+  readonly #open = new Map<string, string>()
+
+  #published = new Set<string>()
+
+  #running = false
+  #again = false
+  #shutdownRequested = false
+  #exited = false
+
+  constructor(options: ServerOptions) {
+    this.#options = options
+    this.#root = options.root
+  }
+
+  get exited(): boolean {
+    return this.#exited
+  }
+
+  get exitCode(): number {
+    return this.#shutdownRequested ? 0 : 1
+  }
+
+  async handle(message: RpcMessage): Promise<void> {
+
+    if (message.method === undefined) return
+
+    switch (message.method) {
+      case 'initialize':
+        this.#root = rootIn(message.params as InitializeParams | undefined) ?? this.#root
+        this.#reply(message.id, {
+          capabilities: {
+            textDocumentSync: { openClose: true, change: SYNC_FULL, save: true },
+
+            diagnosticProvider: {
+              identifier: SOURCE_NAME,
+
+              interFileDependencies: true,
+              workspaceDiagnostics: false,
+            },
+          },
+          serverInfo: { name: named('integrity') },
+        })
+        return
+
+      case 'initialized':
+
+        return
+
+      case 'shutdown':
+        this.#shutdownRequested = true
+        this.#reply(message.id, null)
+        return
+
+      case 'exit':
+        this.#exited = true
+        return
+
+      case 'textDocument/didOpen': {
+        const params = message.params as DidOpenParams | undefined
+        const path = this.#pathOf(params?.textDocument?.uri)
+        if (path === undefined) return
+        this.#open.set(path, typeof params?.textDocument?.text === 'string' ? params.textDocument.text : '')
+        await this.#recompute()
+        return
+      }
+
+      case 'textDocument/didChange': {
+        const params = message.params as DidChangeParams | undefined
+        const path = this.#pathOf(params?.textDocument?.uri)
+        if (path === undefined) return
+
+        const latest = params?.contentChanges?.at(-1)?.text
+        if (typeof latest === 'string') this.#open.set(path, latest)
+        await this.#recompute()
+        return
+      }
+
+      case 'textDocument/didSave':
+        await this.#recompute()
+        return
+
+      case 'textDocument/didClose': {
+        const path = this.#pathOf((message.params as DidOpenParams | undefined)?.textDocument?.uri)
+        if (path === undefined) return
+        this.#open.delete(path)
+        await this.#recompute()
+        return
+      }
+
+      case 'textDocument/diagnostic': {
+        const path = this.#pathOf((message.params as DidOpenParams | undefined)?.textDocument?.uri)
+        const computed = await report(this.#sourceForRoot(), this.#open, this.#published)
+        this.#published = new Set([...computed].filter(([, list]) => list.length > 0).map(([file]) => file))
+        this.#reply(message.id, {
+          kind: 'full',
+          items: path === undefined ? [] : (computed.get(path) ?? []),
+        })
+        return
+      }
+
+      default:
+
+        if (message.id !== undefined && message.id !== null) {
+          this.#options.send({
+            jsonrpc: '2.0',
+            id: message.id,
+            error: { code: METHOD_NOT_FOUND, message: `${message.method} is not implemented by ${SOURCE_NAME}` },
+          })
+        }
+    }
+  }
+
+  #sourceForRoot(): DiagnosticSource {
+    return this.#options.sourceFor(this.#root)
+  }
+
+  #reply(id: RpcMessage['id'], result: unknown): void {
+    if (id === undefined || id === null) return
+    this.#options.send({ jsonrpc: '2.0', id, result })
+  }
+
+  async #recompute(): Promise<void> {
+    if (this.#running) {
+      this.#again = true
+      return
+    }
+
+    this.#running = true
+    try {
+      do {
+        this.#again = false
+        await (this.#options.settle?.() ?? sleep(200))
+        const computed = await report(this.#sourceForRoot(), this.#open, this.#published)
+
+        const nonEmpty = new Set<string>()
+        for (const [path, diagnostics] of computed) {
+          this.#publish(path, diagnostics)
+          if (diagnostics.length > 0) nonEmpty.add(path)
+        }
+        this.#published = nonEmpty
+      } while (this.#again)
+    } finally {
+      this.#running = false
+    }
+  }
+
+  #publish(path: string, diagnostics: readonly Diagnostic[]): void {
+    this.#options.send({
+      jsonrpc: '2.0',
+      method: 'textDocument/publishDiagnostics',
+      params: { uri: pathToFileURL(resolve(this.#root, path)).href, diagnostics },
+    })
+  }
+
+  #pathOf(uri: unknown): string | undefined {
+    if (typeof uri !== 'string' || !uri.startsWith('file://')) return undefined
+    let absolute: string
+    try {
+      absolute = fileURLToPath(uri)
+    } catch {
+      return undefined
+    }
+    const path = relativeTo(this.#root, absolute).split('\\').join('/')
+
+    return path.startsWith('..') || path.startsWith('/') ? undefined : path
+  }
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((done) => setTimeout(done, ms))
+
+function rootIn(params: InitializeParams | undefined): string | undefined {
+  const folder = params?.workspaceFolders?.[0]?.uri
+  for (const uri of [folder, params?.rootUri]) {
+    if (typeof uri !== 'string' || !uri.startsWith('file://')) continue
+    try {
+      return fileURLToPath(uri)
+    } catch {
+      continue
+    }
+  }
+  return typeof params?.rootPath === 'string' ? params.rootPath : undefined
+}

package/dist/integrity/sealed.js

@@ -1,11 +1,11 @@
 export const SEALED = {
     'attach.js': 'e879e49449a3b90118335ab4d2ea6666956da92203438fac7b88ff3a65a79103',
-    'check-threads.js': '1754d3acf4e5ea45ce11bf62b1404d59fa027eb22450e253e303acd13f75f6d8',
+    'check-threads.js': '3c943a890af508bfeb0071974ab74ff3f90ff3ce5e7cd1ffa2e2580c6214b3e2',
     'constraint.js': 'c6eebad19fc11c42c095d82f5658c204f322d136bcbaab98aa9fc06dfa625afb',
     'generators/compiler.js': 'c6db73bfd31513d8334ef5cd063fb5f12b89c56739ff0f2b73249252d1817cdc',
     'generators/gate.js': 'f865f469f13b9e3b2eb120bd233b3e286c0df30a4cdf15cd20be4cb995854f88',
     'generators/issues.js': '21cd7349d3375f15cb8b1a0c31714ab645b021b952275046b56357fba68478b8',
-    'generators/publish.js': 'dcbeaf744dd786e8a606fa9d79fb4d3e3cfa6ae1a1432261547f1e4ef186b81e',
+    'generators/publish.js': 'f19114019854ace16fd5ca94c42cbffd838894ce9e7679d6afd4cf26e2bdddd5',
     'generators/rule.js': '82bdfefbf394528fa4e7994a60eb423b3188277571937e161648f72666728aa4',
     'generators/seal.js': '39fb8ab5c95b9c0fd1d3d38090785b2e1890653bb1d0454868426b67b28abe3a',
     'generators/trial.js': 'a2ef8fda83bb2894ae088a0d7887a4e49b9693fa1a7e1345879aaa63041914b0',

package/dist/integrity/sealed.ts

@@ -0,0 +1,56 @@
+export const SEALED: Readonly<Record<string, string>> = {
+  'attach.js': 'e879e49449a3b90118335ab4d2ea6666956da92203438fac7b88ff3a65a79103',
+  'check-threads.js': '3c943a890af508bfeb0071974ab74ff3f90ff3ce5e7cd1ffa2e2580c6214b3e2',
+  'constraint.js': 'c6eebad19fc11c42c095d82f5658c204f322d136bcbaab98aa9fc06dfa625afb',
+  'generators/compiler.js': 'c6db73bfd31513d8334ef5cd063fb5f12b89c56739ff0f2b73249252d1817cdc',
+  'generators/gate.js': 'f865f469f13b9e3b2eb120bd233b3e286c0df30a4cdf15cd20be4cb995854f88',
+  'generators/issues.js': '21cd7349d3375f15cb8b1a0c31714ab645b021b952275046b56357fba68478b8',
+  'generators/publish.js': 'f19114019854ace16fd5ca94c42cbffd838894ce9e7679d6afd4cf26e2bdddd5',
+  'generators/rule.js': '82bdfefbf394528fa4e7994a60eb423b3188277571937e161648f72666728aa4',
+  'generators/seal.js': '39fb8ab5c95b9c0fd1d3d38090785b2e1890653bb1d0454868426b67b28abe3a',
+  'generators/trial.js': 'a2ef8fda83bb2894ae088a0d7887a4e49b9693fa1a7e1345879aaa63041914b0',
+  'lint.js': '63f9957725a94498d7e5a49544da343c5f2e1b3b9c2778000dae4a4f39036ef9',
+  'lsp/bin.js': 'b71d5da40c137dbe87083ad29bf1a54e30a190113b8811602263f4c5a4d5a11c',
+  'lsp/diagnostics.js': '0fd15477b4df60e5ec065bb1a85c5daab6b9b433e730cb836b8ddc747554e0b9',
+  'lsp/findings.js': '72f7d80645c0941926a1cc029417fed93eca87e7d53bf2d032f4ef647fb1f168',
+  'lsp/lint.js': '159b07ffa100a62b2cd445d621606ae0d6b68aacc342cb5fdb3a2f4cadd7f508',
+  'lsp/protocol.js': 'd0ad8650307bf563bd058dc2bbbbc0ec9d4fd6dc2c9120bdc261d57c076ddc5d',
+  'lsp/server.js': 'a9f76280e395a47521973a14f3769c4df9e8c1153d29dedc535f56276e5a2e2e',
+  'slopnator.js': '804adba20c269c1134fd09e075d354db73b79cfd00c4b4ce66c1e40279670905',
+  'slopnators/sl_broken_lineage.js': '6d0ee15127166d9792b365e8a4623b5770a57e2ff92c2accf196afbb85052112',
+  'slopnators/sl_declared_elsewhere.js': '394da91ac84369217b4a02bc078ab98f62bf6d522042d84bec82b9705d621751',
+  'slopnators/sl_derived_drift.js': 'f7fb0e26cd6bff9dfe7392e1b1593a51741a6f6fac408bdafbb783e04141cf2f',
+  'slopnators/sl_hardcoded_style.js': 'a2b006990bc33150733645f3c17942ff497e7b3a6565af1331263df36d3b5e0a',
+  'slopnators/sl_inert_island.js': '0900de73ab7439b02a3321a6459e53882cfba6267dc8ef45d630ebe40f4bfa84',
+  'slopnators/sl_inert_slopnator.js': 'e3c35cfa2b094e1e2fd6824b75138cf44e8edb5ec396375d67e47897d84c45d7',
+  'slopnators/sl_missing_row.js': 'd942940388a873bebeff72d93cdb5fef20ba88e4fe29c1aa68e2f42389714a4a',
+  'slopnators/sl_no_barrel.js': '7df2a763d4b4ab16d945341b844271380b25774491bfa9c204dc252910951bc6',
+  'slopnators/sl_no_child_process.js': '24d4f89a1493c95db12e92a34dc4281a422226f638a47c795f26447090e056a1',
+  'slopnators/sl_no_comment.js': '4c4b9b502d6b33ed00d653d0b190d8f95b02bc5ef10da87f97913ca425f59f40',
+  'slopnators/sl_no_dispatch_bypass.js': '1def29fca350861b7185129180edd4727199e0f2bba92a0e0a8c0af437cbb382',
+  'slopnators/sl_no_import_cycle.js': '7ab70e4c182e88f73b4af75cddef9655a49996b8c70fcc2dcebd5f4aeb5fef92',
+  'slopnators/sl_no_such_command.js': 'fe037c2ad6891fd3c0338dd84c7007110c0bcd272a12bd8f1cb85ec779df7a8b',
+  'slopnators/sl_only_takes_a_literal.js': '3d5074f9c6a9bb581c80af8aa6d4a6793e29ac93c793367a67326acc1612c8fe',
+  'slopnators/sl_secret_literal.js': 'bc3987627f3b2892eec169d775771b6309d47b2c93e98c1bccad3f3ed5c5d2b6',
+  'slopnators/sl_stale_path.js': '3cc4050cb9ca2875afbb69c818d20d06e82f36a762ec48bd033c342a7023ff8a',
+  'slopnators/sl_twice_meant.js': '6fc5aaf29b635335bd4963931475e7334110439f8305737786c01be39f81230c',
+  'slopnators/sl_twice_parented.js': 'caa590bc4c11dbebe971f5a611a1712a529cc5a2900f37ba43cfa6b67a0a722b',
+  'slopnators/sl_undeclared_crossing.js': '47e41a38334a4b5a3eb0616d675dc46c5e4d6ce1138710b4470acc276e6ddec5',
+  'slopnators/sl_undeclared_destination.js': '3bbf07029a31eb31fa6556b686d067aae0cd5bf9487fe6ca1896984a55970a5c',
+  'slopnators/sl_undeclared_element.js': '2aa469ffdd58f104936904cbee2c95cb38182a2ac1057e0caa4db3d85e81331c',
+  'slopnators/sl_undeclared_node.js': '84c069a7d1bdec3d3c950ad40e016c129f280796b63a196a7866232e14995443',
+  'slopnators/sl_undeclared_operation.js': 'bc3fa4efc83bf5641020373d0f1506856c6272c3d59e4c4d261e3076f69a155e',
+  'slopnators/sl_undeclared_variant.js': 'e41ec11c9f4baf52dbea1aa7828238e5738de609ea47cdcac793cbe6198df770',
+  'slopnators/sl_undescribed.js': '15c6139a4afc3a4dc1a6196ec1acc2af5066a3330343074f6e2b321291cdbbd0',
+  'slopnators/sl_ungoverned_island.js': '555ae51adf994c5fce4ce51701af7d022be8824c001eeb132403fd6342a12a49',
+  'slopnators/sl_unkept_rows.js': '8abd67e8b8347a6dd9abd20fb7719d4f10553d6f329001a34ccc3e063d448e1d',
+  'slopnators/sl_unnamed_island.js': '0c92c5b6fdf59fb97448f24d72b883cd64317c23280316e043f993e7b75ac1da',
+  'slopnators/sl_unpaired_member.js': 'aafba4f829ef038289176b6e5ea6622494eba1982268d8d52b44f8c9889943e9',
+  'slopnators/sl_unpaired_slopnator.js': '2fa5b8c3c8b6a8a71466086f1d3ae32ea16fd22c49b113225e3c9a7e76eda45e',
+  'slopnators/sl_unprefixed_member.js': '67640331089c55ac59e7950e3c919144740309fb4a91cf0af87c41edb761f75d',
+  'slopnators/sl_unseamed_reach.js': 'd27a64c85b221e7c5bac99ab9d36955ad4945520d2b9e5ec75927574ca454cda',
+  'slopnators/sl_unthreaded.js': 'b686212f3515eb2769030979f7141d236677c9f3c1802e436f254ea5410a2361',
+  'slopnators/sl_untranslated_key.js': '224e80a4f34ce760502ee256347c9191e8d103e8b0ff58ef995c10111ddf2854',
+  'slopnators/sl_unversioned.js': 'df73b3186e42e6b58e7fb3fd48c3146a2d3902a337861a6ccb52f433a569e392',
+  'sweep.js': '2402ba042f87e693bf785d8e81b40870dd2fec539a70a9593d7ecba767dcda2c',
+}