@prestack/thread 0.0.1 → 0.0.3

package/dist/integrity/generators/trial.ts

@@ -0,0 +1,320 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { exit, invoked } from '../../core/invoked.ts'
+
+import type { Linter as LinterType, Rule } from 'eslint'
+import { Linter } from 'eslint'
+
+import type { Constraint } from '../constraint.ts'
+
+const TREE = findTree()
+import { CONSTRAINTS } from '../constraint.ts'
+import { NOT_WRITTEN, ROOT, governs, load, proofsOf, reads, rules, slopnatorName, sweeps, write, type Byproduct, type Proof, type Slopnator, type Sourced } from '../slopnator.ts'
+import { forget } from '../slopnators/sl_unthreaded.ts'
+import { findTree, inTree } from '../../core/tree.ts'
+
+export const TRIALS_PATH = `${findTree().name}/_generated/trials.ts`
+
+const PROBE = 'probe.tsx'
+
+const WRAPPINGS: readonly ((source: string) => string)[] = [
+  (source) => source,
+  (source) => `const _probe = { ${source} }`,
+  (source) => `const _probe = <Probe ${source} />`,
+  (source) => `const _probe = () => { ${source} }`,
+  (source) => `const _probe = <Probe>{${source}}</Probe>`,
+]
+
+export interface Scenario {
+  readonly files: readonly Sourced[]
+  readonly at: string
+}
+
+export interface Trial {
+  readonly id: string
+  readonly rule: string
+  readonly name: string
+  readonly scenario: Scenario
+  readonly verdict: { readonly reports: boolean }
+  readonly requires: string
+}
+
+export interface Derivation {
+  readonly trials: readonly Trial[]
+}
+
+export interface Outcome {
+  readonly id: string
+  readonly rule: string
+  readonly passed: boolean
+  readonly failures: readonly string[]
+  readonly parsed: boolean
+}
+
+export interface Run {
+  readonly outcomes: readonly Outcome[]
+  readonly passed: number
+  readonly failed: number
+  readonly measured: number
+}
+
+export function probeAt(rule: Constraint): string {
+  const path = rule.where.paths[0] ?? 'src/'
+  if (path === '.') return PROBE
+  return path.endsWith('/') ? `${path}${PROBE}` : `${path}/${PROBE}`
+}
+
+function requiresOf(rule: Constraint, reports: boolean): string {
+  return reports
+    ? `${rule.id} reports on this source, at a path it governs`
+    : `${rule.id} stays silent on this source — the fix it recommends is not itself refused`
+}
+
+function scenarioOf(rule: Constraint, proof: Proof): Scenario {
+  if (typeof proof !== 'string') return proof
+  const path = probeAt(rule)
+  return { files: [{ at: path, source: proof }], at: path }
+}
+
+function spoken(scenario: Scenario): string {
+  const target = scenario.files.find((file) => file.at === scenario.at) ?? scenario.files[0]
+  const rest = scenario.files.length - 1
+  return `${target?.source ?? ''}${rest > 0 ? ` (beside ${String(rest)} more file(s))` : ''}`
+}
+
+export function deriveTrials(all: readonly Constraint[], slopnators: ReadonlyMap<string, Slopnator>): Derivation {
+  const trials: Trial[] = []
+
+  for (const rule of all) {
+    const proofs = proofsOf(rule, slopnators)
+    const put = (proof: Proof, index: number, reports: boolean): void => {
+      const scenario = scenarioOf(rule, proof)
+      trials.push({
+        id: `trl_rule_${rule.id.replace(/-/g, '_')}_${reports ? 'refuses' : 'accepts'}_${String(index)}`,
+        rule: rule.id,
+        name: `${rule.id} ${reports ? 'refuses' : 'accepts'}: ${spoken(scenario)}`,
+        scenario,
+        verdict: { reports },
+        requires: requiresOf(rule, reports),
+      })
+    }
+    proofs.wrong.forEach((proof, index) => { put(proof, index, true) })
+    proofs.right.forEach((proof, index) => { put(proof, index, false) })
+  }
+
+  return { trials: trials.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) }
+}
+
+export function trialsByproduct(derivation: Derivation): Byproduct {
+  return {
+    path: TRIALS_PATH,
+    content: `export const RULE_TRIALS = ${JSON.stringify(derivation.trials, null, 2)} as const
+`,
+  }
+}
+
+function config(rule: Constraint, module: Rule.RuleModule, parser: unknown): Parameters<LinterType['verify']>[1] {
+  return [
+    {
+      files: ['**/*.ts', '**/*.tsx'],
+      languageOptions: {
+        parser,
+        parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
+      },
+      plugins: { rule: { rules: { [rule.id]: module } } },
+      rules: { [`rule/`]: 'error' },
+    },
+  ] as unknown as Parameters<LinterType['verify']>[1]
+}
+
+export function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule, parser: unknown, slopnator?: Slopnator): Outcome {
+  const linter = new Linter()
+  const failures: string[] = []
+
+  if (!governs(rule, trial.scenario.at)) {
+    return {
+      id: trial.id,
+      rule: rule.id,
+      passed: false,
+      parsed: false,
+      failures: [`the trial's own path "${trial.scenario.at}" is not one the rule governs, so nothing could have run`],
+    }
+  }
+
+  const target = trial.scenario.files.find((file) => file.at === trial.scenario.at)
+  if (target === undefined) {
+    return {
+      id: trial.id,
+      rule: rule.id,
+      passed: false,
+      parsed: false,
+      failures: [`the scenario writes no file at "${trial.scenario.at}", the path it lints, so nothing could have been measured`],
+    }
+  }
+
+  for (const file of trial.scenario.files) {
+    if (!existsSync(join(ROOT, file.at))) continue
+    return {
+      id: trial.id,
+      rule: rule.id,
+      passed: false,
+      parsed: false,
+      failures: [`the scenario would overwrite "${file.at}", which is a real file in this repository — a trial may not stand on a path somebody authored`],
+    }
+  }
+
+  const written: string[] = []
+  const created: string[] = []
+  let parsed = false
+  let satisfied = false
+
+  try {
+    for (const file of trial.scenario.files) {
+      const path = join(ROOT, file.at)
+      const made = mkdirSync(dirname(path), { recursive: true })
+      if (made !== undefined) created.push(made)
+      writeFileSync(path, file.source)
+      written.push(path)
+    }
+    forget()
+
+    const path = join(ROOT, trial.scenario.at)
+
+    if (slopnator !== undefined && !reads(slopnator)) {
+      parsed = true
+      satisfied = slopnator.checks(ROOT).length > 0 === trial.verdict.reports
+    } else if (slopnator !== undefined && sweeps(slopnator)) {
+      const held = slopnator.holds(undefined, {
+        filename: trial.scenario.at,
+        text: target.source,
+        ancestors: () => [],
+        comments: () => [],
+      })
+      parsed = true
+      satisfied = (held !== false && held !== NOT_WRITTEN) === trial.verdict.reports
+    } else {
+      for (const wrap of WRAPPINGS) {
+        const text = wrap(target.source)
+        writeFileSync(path, text)
+        const messages = linter.verify(text, config(rule, module, parser), trial.scenario.at)
+        if (messages.some((message) => message.fatal === true)) continue
+        parsed = true
+        satisfied = messages.some((message) => message.ruleId === `rule/`) === trial.verdict.reports
+        break
+      }
+    }
+  } finally {
+    for (const path of written) if (existsSync(path)) rmSync(path)
+    for (const path of created) if (existsSync(path)) rmSync(path, { recursive: true })
+    forget()
+  }
+
+  if (!parsed) {
+    failures.push('no wrapping of this source parsed, so nothing was measured — a trial that cannot run is not a trial that passed')
+  } else if (!satisfied) {
+    failures.push(
+      trial.verdict.reports
+        ? `expected  to report on this source and it stayed silent — the rule documents a form its own slopnator does not refuse`
+        : `expected  to stay silent on this source and it reported — the rule refuses the fix it recommends`,
+    )
+  }
+
+  return { id: trial.id, rule: rule.id, passed: failures.length === 0, parsed, failures }
+}
+
+export function runTrials(
+  trials: readonly Trial[],
+  all: readonly Constraint[],
+  rules: Readonly<Record<string, Rule.RuleModule>>,
+  parser: unknown,
+  slopnators?: ReadonlyMap<string, Slopnator>,
+): Run {
+  const byName = new Map(all.map((rule) => [rule.id, rule]))
+  const outcomes = trials.map((trial): Outcome => {
+    const rule = byName.get(trial.rule)
+    const module = rules[trial.rule]
+    if (rule === undefined || module === undefined) {
+      return {
+        id: trial.id,
+        rule: trial.rule,
+        passed: false,
+        parsed: false,
+        failures: [`no rule named "${trial.rule}" is registered, so this trial is about nothing — regenerate with \`thread trials\``],
+      }
+    }
+    return runTrial(trial, rule, module, parser, slopnators?.get(slopnatorName(rule.id)))
+  })
+
+  return {
+    outcomes,
+    passed: outcomes.filter((outcome) => outcome.passed).length,
+    failed: outcomes.filter((outcome) => !outcome.passed).length,
+    measured: outcomes.filter((outcome) => outcome.parsed).length,
+  }
+}
+
+if (invoked(import.meta.url)) {
+  const own = await rules()
+  const governing = own ?? CONSTRAINTS
+  const source =
+    own === undefined
+      ? `the ${String(CONSTRAINTS.length)} constraint(s) this tree authors`
+      : `the ${String(own.length)} rule(s) this tree declares — a shipped constraint is proved in the package that ships it, against the paths that package governs`
+  const slopnators = await load(ROOT, governing)
+  const derivation = deriveTrials(governing, slopnators)
+  const byproduct = trialsByproduct(derivation)
+
+  if (process.argv.includes('--check')) {
+    const path = join(ROOT, byproduct.path)
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : ''
+    const drifted = current !== byproduct.content
+    if (drifted) console.error(`trial: ${byproduct.path} is not what the rules derive. Run \`thread trials\` and commit the result.`)
+    console.log(`trial: ${String(derivation.trials.length)} derived from ${source}, ${String(drifted ? 1 : 0)} findings.`)
+    exit(drifted ? 1 : 0)
+  }
+
+  if (process.argv.includes('--try')) {
+    const at = process.argv.indexOf('--rule')
+    const only = at === -1 ? undefined : (process.argv[at + 1] ?? '').split(',').map((one) => one.trim()).filter(Boolean)
+    const unknown = (only ?? []).filter((id) => !governing.some((rule) => rule.id === id))
+    if (unknown.length > 0) {
+      console.error(`trial: no rule is called ${unknown.join(', ')} — a filter naming nothing would measure nothing and exit 0`)
+      exit(1)
+    }
+    const chosen = only === undefined ? derivation.trials : derivation.trials.filter((trial) => only.includes(trial.rule))
+    if (chosen.length === 0) {
+      if (only !== undefined) {
+        console.error('trial: the filter selected no trials, and measuring nothing must not exit 0')
+        exit(1)
+      }
+      if (governing.length > 0) {
+        console.error(
+          `trial: ${String(governing.length)} rule(s) govern and none derived a trial — every rule owes a \`wrong\` and a \`right\`, so measuring nothing must not exit 0`,
+        )
+        exit(1)
+      }
+      console.log(`trial: nothing to prove — ${source}.`)
+      exit(0)
+    }
+
+    const { default: plugin } = await import('../lint.ts')
+    const parser = (await import('typescript-eslint')).parser
+    const run = runTrials(chosen, governing, plugin.rules, parser, slopnators)
+    for (const outcome of run.outcomes) {
+      if (outcome.passed) continue
+      for (const failure of outcome.failures) console.error(`trial: ${outcome.id} — ${failure}`)
+    }
+    console.log(`trial: ${String(run.passed)} of ${String(run.outcomes.length)} passed, ${String(run.measured)} measured.`)
+    if (only !== undefined) {
+      console.log(
+        `trial: PARTIAL RUN — ${String(derivation.trials.length - chosen.length)} of ${String(derivation.trials.length)} derived trials did not run. \`thread trials\` with no arguments runs every one.`,
+      )
+    }
+    exit(run.failed === 0 ? 0 : 1)
+  }
+
+  write(ROOT, byproduct)
+  console.log(`trial: wrote ${byproduct.path} — ${String(derivation.trials.length)} trials from ${source}.`)
+}

package/dist/integrity/lint.ts

@@ -0,0 +1,227 @@
+import { execFileSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+import { Linter, type Rule } from 'eslint'
+import tseslint from 'typescript-eslint'
+
+import { THING } from '../core/scope.ts'
+import { CONSTRAINTS, type Constraint } from './constraint.ts'
+import {
+  NOT_WRITTEN,
+  governs,
+  reads,
+  visits,
+  load,
+  ROOT,
+  rules as appRules,
+  slopnatorName,
+  type Slopnator,
+  type SlopnatorContext,
+} from './slopnator.ts'
+
+
+
+const PROBE: SlopnatorContext = {
+  filename: 'probe.ts',
+  text: '',
+  ancestors: () => [],
+  comments: () => [],
+}
+
+export function ruleMessage(rule: Constraint): string {
+  const cites = (rule.cites ?? []).map((cite) => `${cite.on} — ${cite.said}`).join(' · ')
+  return cites === '' ? `${rule.bans} — ${rule.because}. Instead: ${rule.instead}.` : `${rule.bans} — ${rule.because}. Instead: ${rule.instead}. (${cites})`
+}
+
+const oneLine = (text: string): string => text.replace(/\s*\n\s*/g, ' ').trim()
+
+export function agentInstructions(): readonly string[] {
+  return [...CONSTRAINTS]
+    .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
+    .map(
+      (rule) =>
+        `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(rule.wrong)}\`. Right: \`${oneLine(rule.right)}\`. [${rule.id}]`,
+    )
+}
+
+export function defineRule(rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): Constraint {
+  const expected = slopnatorName(rule.id)
+
+  if (rule.where.paths.length === 0) {
+    throw new Error(
+      `rule "${rule.id}" names no path, so it governs nothing. A rule that cannot fire is indistinguishable from a rule being obeyed.`,
+    )
+  }
+
+  const found = slopnators.get(expected)
+  if (found === undefined) {
+    throw new Error(
+      `"${rule.id}" names "${expected}", and no such file is beside the tree or shipped with the package. ` +
+        'One that cannot run reads as enforced, reports nothing, and is indistinguishable from one being obeyed. ' +
+        'Seed it.',
+    )
+  }
+
+  return rule
+}
+
+export function defineRules(slopnators: ReadonlyMap<string, Slopnator>): readonly Constraint[] {
+  const seen = new Set<string>()
+  for (const rule of GOVERNING) {
+    if (seen.has(rule.id)) throw new Error(`rule "${rule.id}" is declared twice in packages/core/src/integrity/constraint.ts`)
+    seen.add(rule.id)
+    defineRule(rule, slopnators)
+  }
+  return GOVERNING
+}
+
+export function ruleRule(rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): Rule.RuleModule {
+  const slopnator = slopnators.get(slopnatorName(rule.id))
+  return {
+    meta: {
+      type: 'problem',
+      docs: { description: rule.bans },
+      schema: [],
+      ...(slopnator !== undefined && reads(slopnator) && slopnator.fixes !== undefined ? { fixable: 'code' as const } : {}),
+      messages: { broken: `${ruleMessage(rule)} Found: {{found}}.` },
+    },
+    create(context) {
+      if (!governs(rule, context.filename)) return {}
+      const found = slopnator
+      if (found === undefined || !visits(found)) return {}
+      const visit = (node: unknown): void => {
+        const at: SlopnatorContext = {
+          filename: context.filename,
+          text: context.sourceCode.getText(),
+          ancestors: () => context.sourceCode.getAncestors(node as never),
+          comments: () =>
+            context.sourceCode.getAllComments().map((comment) => ({
+              value: comment.value,
+              range: (comment.range ?? [0, 0]) as readonly [number, number],
+            })),
+        }
+        const held = found.holds(node, at)
+        if (held === false || held === NOT_WRITTEN) return
+        const mend = found.fixes
+        const mended = mend === undefined ? undefined : mend(node, at)
+        context.report({
+          node: node as never,
+          messageId: 'broken',
+          data: { found: typeof held === 'string' ? held : slopnatorName(rule.id) },
+          ...(mended === undefined ? {} : { fix: (fixer) => fixer.replaceTextRange([0, at.text.length], mended) }),
+        })
+      }
+      return Object.fromEntries(found.on.map((type) => [type, visit]))
+    },
+  }
+}
+
+export function ruleRules(slopnators: ReadonlyMap<string, Slopnator>): Readonly<Record<string, Rule.RuleModule>> {
+  return Object.fromEntries(GOVERNING.map((rule) => [rule.id, ruleRule(rule, slopnators)]))
+}
+
+export function ruleSeverities(): Readonly<Record<string, 'error' | 'warn'>> {
+  return Object.fromEntries(
+    GOVERNING.map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? ('warn' as const) : ('error' as const)]),
+  )
+}
+
+const GOVERNING = [...CONSTRAINTS, ...((await appRules()) ?? [])]
+const SLOPNATORS = await load(ROOT, GOVERNING)
+
+defineRules(SLOPNATORS)
+
+export const plugin = { rules: ruleRules(SLOPNATORS) }
+
+export default plugin
+
+function ignored(): readonly string[] {
+  try {
+    return execFileSync('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], {
+      cwd: ROOT,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .split('\n')
+      .filter(Boolean)
+      .map((one) => (one.endsWith('/') ? one + '**' : one))
+  } catch {
+    return []
+  }
+}
+
+export const rules = {
+  files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.mjs', '**/*.js'],
+  ignores: ignored(),
+  languageOptions: {
+    parser: tseslint.parser,
+    parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
+  },
+  plugins: { lint: plugin },
+  rules: ruleSeverities(),
+}
+
+export function ruleDeclarations(): readonly (Constraint & { readonly name: string })[] {
+  return [...CONSTRAINTS]
+    .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
+    .map((rule) => ({ ...rule, name: rule.id }))
+}
+
+export interface RuleViolation {
+  readonly file: string
+  readonly line: number
+  readonly column: number
+  readonly rule: string
+
+  readonly message: string
+
+  readonly bans?: string
+
+  readonly instead?: string
+
+  readonly wrong?: string
+
+  readonly right?: string
+}
+
+export type RuleRunner = (file: string, source: string) => readonly RuleViolation[]
+
+export function theRules(): RuleRunner {
+  const linter = new Linter()
+  const declared = new Map(ruleDeclarations().map((one) => [one.name, one]))
+
+  const config = [
+    {
+      files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'],
+
+      linterOptions: { noInlineConfig: true },
+      languageOptions: {
+        parser: tseslint.parser,
+        parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
+      },
+      plugins: { [`@${THING}`]: plugin },
+      rules: Object.fromEntries(
+        GOVERNING.map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']),
+      ),
+    },
+  ] as unknown as Parameters<InstanceType<typeof Linter>['verify']>[1]
+
+  return (file, source) =>
+    linter
+      .verify(source, config, file)
+      .filter((message) => message.ruleId != null)
+      .map((message) => {
+        const rule = String(message.ruleId).replace(`@${THING}/`, '')
+        const found = declared.get(rule)
+        return {
+          file,
+          line: message.line,
+          column: message.column,
+          rule,
+          message: message.message,
+          ...(found === undefined
+            ? {}
+            : { bans: found.bans, instead: found.instead, wrong: found.wrong, right: found.right }),
+        }
+      })
+}

package/dist/integrity/lsp/bin.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import { cwd, exit, stderr, stdin, stdout } from 'node:process'
+
+import { repoSource } from './diagnostics.ts'
+import { encode, MessageBuffer } from './protocol.ts'
+import { LspServer } from './server.ts'
+
+const server = new LspServer({
+  root: cwd(),
+  sourceFor: repoSource,
+  send: (message) => stdout.write(encode(message)),
+})
+
+const buffer = new MessageBuffer()
+
+let queue: Promise<void> = Promise.resolve()
+
+const fatal = (error: unknown): never => {
+  stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`)
+  exit(1)
+}
+
+stdin.on('data', (chunk: Buffer) => {
+  let messages
+  try {
+    messages = buffer.push(chunk)
+  } catch (error) {
+    fatal(error)
+    return
+  }
+
+  for (const message of messages) {
+    queue = queue.then(async () => {
+      await server.handle(message)
+      if (server.exited) exit(server.exitCode)
+    })
+    queue.catch(fatal)
+  }
+})
+
+stdin.on('end', () => exit(server.exitCode))

package/dist/integrity/lsp/diagnostics.ts

@@ -0,0 +1,92 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { detailOf, rangeOf, type Finding } from './findings.ts'
+import { lintFindings } from './lint.ts'
+
+export interface DiagnosticSource {
+
+  lint(relative: string, text: string): Promise<readonly Finding[]>
+
+  read(relative: string): string | null
+}
+
+export function repoSource(root: string): DiagnosticSource {
+  return {
+    lint: (relative, text) => lintFindings(root, relative, text),
+    read: (relative) => {
+      try {
+        return readFileSync(join(root, relative), 'utf8')
+      } catch {
+
+        return null
+      }
+    },
+  }
+}
+
+export const ERROR = 1
+export const WARNING = 2
+
+export interface Position {
+  readonly line: number
+  readonly character: number
+}
+
+export interface Diagnostic {
+  readonly range: { readonly start: Position; readonly end: Position }
+  readonly severity: typeof ERROR | typeof WARNING
+  readonly source: string
+  readonly code: string
+  readonly message: string
+}
+
+export const SOURCE_NAME = 'thread'
+
+export function toDiagnostic(finding: Finding, text: string): Diagnostic {
+  const at = rangeOf(finding, text)
+  return {
+    range: {
+      start: { line: at.line - 1, character: at.column - 1 },
+      end: { line: (at.endLine ?? at.line) - 1, character: (at.endColumn ?? at.column) - 1 },
+    },
+    severity: finding.severity === 'error' ? ERROR : WARNING,
+    source: SOURCE_NAME,
+    code: finding.check,
+    message: detailOf(finding),
+  }
+}
+
+export async function report(
+  source: DiagnosticSource,
+  open: ReadonlyMap<string, string>,
+  previous: ReadonlySet<string> = new Set(),
+): Promise<ReadonlyMap<string, readonly Diagnostic[]>> {
+  const findings: Finding[] = []
+
+  for (const [relative, text] of open) {
+    findings.push(...(await source.lint(relative, text)))
+  }
+
+  const byFile = new Map<string, Finding[]>()
+  for (const finding of findings) {
+    const bucket = byFile.get(finding.file)
+    if (bucket === undefined) byFile.set(finding.file, [finding])
+    else bucket.push(finding)
+  }
+
+  const published = new Map<string, readonly Diagnostic[]>()
+  for (const [relative, group] of byFile) {
+    const text = open.get(relative) ?? source.read(relative) ?? ''
+    published.set(
+      relative,
+      group.map((finding) => toDiagnostic(finding, text)),
+    )
+  }
+
+  for (const relative of [...previous, ...open.keys()]) {
+    if (!published.has(relative)) published.set(relative, [])
+  }
+
+  return published
+}