@prestack/thread 0.0.1 → 0.0.2

package/dist/integrity/slopnator.ts

@@ -0,0 +1,350 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { dirname, join, sep } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import { invoked } from '../core/invoked.ts'
+
+import { listBounds, quoted, withSeed } from '../core/rows.ts'
+
+import { CONSTRAINTS, type Constraint } from './constraint.ts'
+import { SEALED } from './sealed.ts'
+import { findTree, inTree } from '../core/tree.ts'
+
+export const NOT_WRITTEN = Symbol.for('thread.slopnator.not_written')
+
+const HOME = dirname(fileURLToPath(import.meta.url))
+
+const BUILT = dirname(dirname(HOME))
+
+export const SHIPPED = `${HOME}/slopnators`
+
+export const SEEDED = `${findTree().name}/slopnators`
+
+function homes(root: string): readonly string[] {
+  return [SHIPPED, join(root, SEEDED)]
+}
+
+export const ROOT = `${findTree().at}/`
+
+export const DEPTH = 'THREAD_DEPTH'
+
+export const CEILING = 1
+
+export const SPAWN_TIMEOUT = 120_000
+
+export const SPAWN_BUFFER = 8 * 1024 * 1024
+
+export function nested(): boolean {
+  return Number(process.env[DEPTH] ?? '0') >= CEILING
+}
+
+export function ran(command: string, options: { readonly cwd: string; readonly args?: readonly string[] }): { readonly status: number | null; readonly said: string } | undefined {
+  if (nested()) return undefined
+  const depth = Number(process.env[DEPTH] ?? '0')
+  const out = spawnSync(command, [...(options.args ?? [])], {
+    shell: options.args === undefined,
+    cwd: options.cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: SPAWN_TIMEOUT,
+    killSignal: 'SIGKILL',
+    maxBuffer: SPAWN_BUFFER,
+    env: { ...process.env, [DEPTH]: String(depth + 1) },
+  })
+  return { status: out.status, said: `${String(out.stdout ?? '')}${String(out.stderr ?? '')}` }
+}
+
+export interface SlopnatorContext {
+  readonly filename: string
+  readonly text: string
+  readonly ancestors: () => readonly unknown[]
+  readonly comments: () => readonly Spoken[]
+}
+
+export interface Spoken {
+  readonly value: string
+  readonly range: readonly [number, number]
+}
+
+export interface Proves {
+  readonly wrong: readonly Proof[]
+  readonly right: readonly Proof[]
+}
+
+export interface Reads {
+  readonly holds: (node: unknown, at: SlopnatorContext) => boolean | string | typeof NOT_WRITTEN
+  readonly fixes?: (node: unknown, at: SlopnatorContext) => string | undefined
+  readonly proves: Proves
+}
+
+export interface Reading extends Reads {
+  readonly on?: readonly string[]
+}
+
+export interface Running {
+  readonly checks: (root: string) => readonly string[]
+  readonly proves: Proves
+}
+
+export type Slopnator = Reading | Running
+
+export type Visiting = Reading & { readonly on: readonly string[] }
+
+export const reads = (one: Slopnator): one is Reading => 'holds' in one
+
+export const visits = (one: Slopnator): one is Visiting => 'holds' in one && one.on !== undefined
+
+export const sweeps = (one: Slopnator): one is Reading => 'holds' in one && one.on === undefined
+
+export interface Sourced {
+  readonly at: string
+  readonly source: string
+}
+
+export type Proof = string | { readonly files: readonly Sourced[]; readonly at: string }
+
+export interface Byproduct {
+  readonly path: string
+  readonly content: string
+}
+
+export function slopnatorName(rule: string): string {
+  return `sl_${rule
+    .replace(/[^a-zA-Z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .toLowerCase()}`
+}
+
+const CANONICAL_TREE = 'threads'
+
+const TREE = findTree().name
+
+function parts(one: string): readonly string[] {
+  return one.split('\\').join('/').split('/').filter((part) => part !== '')
+}
+
+function wanted(fragment: string): readonly string[] {
+  const all = parts(fragment)
+  return all[0] === CANONICAL_TREE ? [TREE, ...all.slice(1)] : all
+}
+
+export function names(fragment: string, path: readonly string[]): boolean {
+  if (fragment === '.') return true
+  const want = wanted(fragment)
+  if (want.length === 0) return false
+  if (!fragment.endsWith('/')) return want.join('/') === path.join('/')
+  for (let at = 0; at + want.length < path.length; at += 1) {
+    if (want.every((part, step) => part === path[at + step])) return true
+  }
+  return false
+}
+
+export function governs(rule: Constraint, filename: string): boolean {
+  const path = parts(filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename)
+  if ((rule.where.except ?? []).some((fragment) => names(fragment, path))) return false
+  return rule.where.paths.some((fragment) => names(fragment, path))
+}
+
+export class UnloadableSlopnatorError extends Error {
+  constructor(rule: string, at: string, because: string) {
+    super(
+      `rule "${rule}" names a slopnator at ${at}, the file is on disk, and loading it threw: ${because}. ` +
+        'A slopnated that cannot be imported reads from every caller exactly like a slopnator that found nothing — ' +
+        'the sweep skips it, the trial falls through, and the rule reports green while enforcing nothing. ' +
+        'Fix the import, or delete the rule.',
+    )
+    this.name = 'UnloadableSlopnatorError'
+  }
+}
+
+export class UnreadableRulesError extends Error {
+  constructor(at: string, because: string) {
+    super(
+      `${at} is where this tree states the rules it authors, and reading it threw: ${because}. ` +
+        'A tree whose rules cannot be read reports exactly like a tree that declared none — every surface runs, finds nothing of its own, and exits 0. ' +
+        'Fix the file, or delete it if this tree authors no rules of its own.',
+    )
+    this.name = 'UnreadableRulesError'
+  }
+}
+
+export class BrokenSealError extends Error {
+  constructor(at: string, why: string) {
+    super(
+      `${at} ${why} — this package is not the one that was published, so nothing it refuses or allows can be trusted. ` +
+        'Reinstall it (`pnpm install --frozen-lockfile` re-verifies the published bytes), or if you meant to change it, run `thread seal` and publish that.',
+    )
+    this.name = 'BrokenSealError'
+  }
+}
+
+const INSTALLED = HOME.includes(`${sep}node_modules${sep}`)
+
+export function unsealed(home: string = HOME): readonly string[] {
+  const broken: string[] = []
+  for (const [at, hash] of Object.entries(SEALED)) {
+    let held: Buffer
+    try {
+      held = readFileSync(join(home, at))
+    } catch {
+      broken.push(`${at} is missing`)
+      continue
+    }
+    if (createHash('sha256').update(held).digest('hex') !== hash) broken.push(`${at} differs from the seal`)
+  }
+  return broken
+}
+
+export function verify(): void {
+  if (!INSTALLED) return
+  const broken = unsealed(BUILT)
+  const first = broken[0]
+  if (first !== undefined) throw new BrokenSealError(first.split(' ')[0] ?? '', first.split(' ').slice(1).join(' '))
+}
+
+export async function load(root: string, all: readonly Constraint[]): Promise<ReadonlyMap<string, Slopnator>> {
+  verify()
+  const found = new Map<string, Slopnator>()
+  for (const rule of all) {
+    const name = slopnatorName(rule.id)
+    const at = homes(root)
+      .flatMap((dir) => [join(dir, `${name}.ts`), join(dir, `${name}.js`)])
+      .find((one) => existsSync(one))
+    if (at === undefined) continue
+
+    let module: unknown
+    try {
+      module = await import(pathToFileURL(at).href)
+    } catch (thrown) {
+      throw new UnloadableSlopnatorError(rule.id, at, thrown instanceof Error ? thrown.message : String(thrown))
+    }
+
+    const one = (module as { slopnator?: Slopnator }).slopnator
+    if (one === undefined) {
+      throw new UnloadableSlopnatorError(rule.id, at, 'it exports no `slopnator`')
+    }
+    found.set(name, one)
+  }
+  return found
+}
+
+export function proofsOf(
+  rule: Constraint,
+  slopnators: ReadonlyMap<string, Slopnator>,
+): { readonly wrong: readonly Proof[]; readonly right: readonly Proof[] } {
+  const slopnated = slopnators.get(slopnatorName(rule.id))?.proves
+  return { wrong: [rule.wrong, ...(slopnated?.wrong ?? [])], right: [rule.right, ...(slopnated?.right ?? [])] }
+}
+
+export function scaffold(): string {
+  return `import { NOT_WRITTEN, type Slopnator } from './slopnator.ts'
+
+export const slopnator: Slopnator = {
+  on: [],
+  holds: () => NOT_WRITTEN,
+  proves: { wrong: [], right: [] },
+}
+`
+}
+
+export function write(root: string, byproduct: Byproduct): void {
+  const path = join(root, byproduct.path)
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, byproduct.content, 'utf8')
+}
+
+export function onDisk(root: string): readonly string[] {
+  const found = new Set<string>()
+  for (const dir of homes(root)) {
+    if (!existsSync(dir)) continue
+    for (const file of readdirSync(dir)) {
+      if (file.startsWith('sl_') && file.endsWith('.ts')) found.add(file.replace(/\.ts$/, ''))
+    }
+  }
+  return [...found].sort()
+}
+
+export function named(all: readonly Constraint[]): readonly string[] {
+  return all.map((rule) => slopnatorName(rule.id)).sort()
+}
+
+export async function rules(): Promise<readonly Constraint[] | undefined> {
+  const at = inTree(findTree(), 'rules.ts')
+  if (!existsSync(at)) return undefined
+  let module: { RULES?: readonly Constraint[] }
+  try {
+    module = (await import(pathToFileURL(at).href)) as { RULES?: readonly Constraint[] }
+  } catch (thrown) {
+    throw new UnreadableRulesError(at, thrown instanceof Error ? thrown.message : String(thrown))
+  }
+  if (module.RULES === undefined) throw new UnreadableRulesError(at, 'it exports no `RULES`')
+  return module.RULES
+}
+
+export function seeds(root: string, all: readonly Constraint[]): readonly Byproduct[] {
+  const found = onDisk(root)
+  return named(all)
+    .filter((wanted) => !found.includes(wanted))
+    .map((wanted) => ({ path: `${SEEDED}/${wanted}.ts`, content: scaffold() }))
+}
+
+export const GENERALLY =
+  'The check the rule beside it refuses with. The rule says what is banned and this finds it, reading every file that rule governs and answering whether each one breaks it.'
+
+export function declaring(at: string, says: string): string {
+  return [
+    '      {',
+    "        id: 'slopnator',",
+    `        at: '${at}',`,
+    `        describes: ${quoted(says)},`,
+    '      },',
+  ].join('\n')
+}
+
+export async function declareSeeded(root: string, ids: readonly string[], says?: string): Promise<readonly string[]> {
+  if (ids.length === 0) return []
+  const at = inTree(findTree(), 'rules.ts')
+  let text: string
+  try {
+    text = readFileSync(at, 'utf8')
+  } catch {
+    return []
+  }
+  const where = listBounds(text, 'RULES')
+  if (where === undefined) return []
+
+  const done: string[] = []
+  for (const id of ids) {
+    const next = withSeed(
+      text,
+      listBounds(text, 'RULES') ?? where,
+      id,
+      declaring(`${SEEDED}/${slopnatorName(id)}.ts`, says ?? GENERALLY),
+    )
+    if (next === text) continue
+    text = next
+    done.push(id)
+  }
+  if (done.length > 0) writeFileSync(at, text, 'utf8')
+  return done
+}
+
+if (invoked(import.meta.url)) {
+  const own = (await rules()) ?? []
+  const seeded = seeds(ROOT, own)
+  for (const byproduct of seeded) {
+    write(ROOT, byproduct)
+    console.log(`slopnator: seeded ${byproduct.path}`)
+  }
+
+  const held = new Set(onDisk(ROOT))
+  const declared = await declareSeeded(ROOT, own.filter((rule) => held.has(slopnatorName(rule.id))).map((rule) => rule.id))
+  for (const id of declared) console.log(`slopnator: declared the slopnator for "${id}" in its own row`)
+
+  console.log(
+    `slopnator: ${String(own.length)} rule(s), ${String(seeded.length)} seeded, ${String(declared.length)} declared. ` +
+      `${String(CONSTRAINTS.length)} shipped constraint(s) are authored, not seeded — unpaired-slopnator refuses one whose slopnated is missing.`,
+  )
+}

package/dist/integrity/slopnators/sl_broken_lineage.ts

@@ -0,0 +1,36 @@
+import type { Slopnator } from '../slopnator.ts'
+import { here, names, threaded, unreadable } from './sl_unthreaded.ts'
+import { findTree } from '../../core/tree.ts'
+
+const THREAD_AT = `${findTree().name}/thread.ts`
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (path === THREAD_AT) return false
+
+    if (unreadable(path, at.text) !== undefined) return false
+    const children = names(path, at.text)
+    if (children.length === 0) return false
+    if (threaded().has(path)) return false
+
+    return `this file names ${String(children.length)} child(ren) — ${children.slice(0, 3).join(', ')} — and its own origin does not trace back to threads/, so everything it parents is stranded with it`
+  },
+  proves: {
+    wrong: [
+      "export const M: Threaded = {\n  declares: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
+      "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
+    ],
+    right: [
+      {
+        files: [
+          { at: 'threads/_names_it.ts', source: "export const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_mid.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_mid.ts', source: "export const MID: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_end.ts',\n    },\n  ],\n}\n" },
+          { at: 'scripts/_probe_end.ts', source: 'export const END = 1\n' },
+        ],
+        at: 'scripts/_probe_mid.ts',
+      },
+      'export const PLAIN = 1',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_declared_elsewhere.ts

@@ -0,0 +1,39 @@
+import type { Slopnator } from '../slopnator.ts'
+import { filesGoverned, here, islandsDeclared } from './sl_unthreaded.ts'
+
+const sentence = (describes: string): string => `${describes.split(/ — |\. /)[0] ?? describes}.`
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+
+    for (const island of islandsDeclared()) {
+      if (island.define === undefined) continue
+      const call = new RegExp(`(?<!function\\s)\\b${island.define}\\s*\\(`)
+      if (!call.test(at.text)) continue
+
+      const places = filesGoverned(island.governs)
+      if (places.includes(path)) continue
+
+      const where = places.length === 0 ? 'nowhere — its kind is derived, never authored' : places.join(' or ')
+      return (
+        `\`${island.define}\` is called here and the "${island.id}" island governs ${where}, so the loader never opens this ` +
+        `file for it and the declaration produces nothing. ${sentence(island.describes)}`
+      )
+    }
+
+    return false
+  },
+  proves: {
+    wrong: [
+      "export default defineEvents({ specVersion: 1, events: [] })",
+      "export default definePermissions({ specVersion: 1, entities: [] })",
+      "export default defineMap({ specVersion: 1, screens: [] })",
+    ],
+    right: [
+      "import events from 'app/_declare/events'",
+      "import permissions from 'app/_declare/permissions'",
+      'const screens = useRead(recentScreens)',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_derived_drift.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { Slopnator } from '../slopnator.ts'
+import { atsIn } from './sl_unthreaded.ts'
+import { reached } from '../../core/descend.ts'
+import { findTree } from '../../core/tree.ts'
+
+const ROOT = `${findTree().at}/`
+
+export interface Derivation {
+  readonly at: string
+  readonly by?: string
+  readonly runs?: string
+}
+
+export function derivations(root: string): readonly Derivation[] {
+  const found: Derivation[] = []
+  for (const at of reached()) {
+    let text: string
+    try {
+      text = readFileSync(resolve(root, at), 'utf8')
+    } catch {
+      continue
+    }
+    const threadedDerives = new Set(atsIn(text, new Set(['derives'])))
+    for (const opens of text.matchAll(/^\s*derives:\s*\[/gm)) {
+      const from = opens.index ?? 0
+      let depth = 1
+      let cursor = from + opens[0].length
+      while (cursor < text.length && depth > 0) {
+        const one = text[cursor]
+        if (one === '[') depth += 1
+        else if (one === ']') depth -= 1
+        cursor += 1
+      }
+      const own: string[] = []
+      let nesting = 0
+      for (const line of text.slice(from, cursor).split('\n')) {
+        if (nesting === 1) own.push(line)
+        for (const one of line) {
+          if (one === '[') nesting += 1
+          else if (one === ']') nesting -= 1
+        }
+      }
+      const block = own.join('\n')
+      for (const row of block.split(/^\s*\{$/m)) {
+        const at = /^\s*at:\s*'([^']+)'/m.exec(row)?.[1]
+        const by = /^\s*by:\s*'([^']+)'/m.exec(row)?.[1]
+        const runs = /^\s*runs:\s*'([^']+)'/m.exec(row)?.[1]
+        if (at !== undefined && threadedDerives.has(at)) found.push({ at, by, runs })
+      }
+    }
+  }
+  return found
+}
+
+export const slopnator: Slopnator = {
+  checks: (root) => {
+    const findings: string[] = []
+    const all = derivations(root)
+    const complete = all.filter((one) => one.by !== undefined && one.runs !== undefined)
+    const covered = new Set(complete.map((one) => one.at))
+
+    for (const at of new Set(all.map((one) => one.at))) {
+      if (covered.has(at)) continue
+      findings.push(
+        `${at} sits in a \`derives\` list and no row naming it states both \`by\` and \`runs\` — a byproduct nothing can re-run is a claim, and this check used to drop such a row in silence`,
+      )
+    }
+
+    return findings
+  },
+  proves: {
+    wrong: [
+      {
+        files: [
+          { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm no-such-check',\n    },\n  ],\n}\n" },
+        ],
+        at: 'threads/_drift_probe.ts',
+      },
+      {
+        files: [
+          { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}\n" },
+        ],
+        at: 'threads/_drift_probe.ts',
+      },
+    ],
+    right: [
+      {
+        files: [
+          { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm gate:check',\n    },\n  ],\n}\n" },
+        ],
+        at: 'threads/_drift_probe.ts',
+      },
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_hardcoded_style.ts

@@ -0,0 +1,55 @@
+import ts from 'typescript'
+
+
+import type { Slopnator } from '../slopnator.ts'
+
+const ALONE = /^\s*([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\s*:\s*([^;{}\n]+);\s*$/
+
+const NAMED = /var\(\s*--/
+
+const PIECES = new Set([
+  ts.SyntaxKind.StringLiteral,
+  ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+  ts.SyntaxKind.TemplateHead,
+  ts.SyntaxKind.TemplateMiddle,
+  ts.SyntaxKind.TemplateTail,
+])
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.JSX, at.text)
+    let token = scanner.scan()
+    while (token !== ts.SyntaxKind.EndOfFileToken) {
+      if (PIECES.has(token)) {
+        const said = scanner.getTokenValue()
+        const found = ALONE.exec(said)
+        if (found !== null) {
+          const property = found[1] ?? ''
+          const value = (found[2] ?? '').trim()
+          if (value !== '' && !NAMED.test(value)) {
+            return (
+              `\`${property}\` is written into the compiler with \`${value}\` typed into it, so a ` +
+              'stylesheet carries a decision nothing declared — no rebrand moves it, no mode or theme reaches it, and no sheet knows it is there'
+            )
+          }
+        }
+      }
+      token = scanner.scan()
+    }
+    return false
+  },
+  proves: {
+    wrong: [
+      "lines.push('  body {', '    background: #f8fbfa;', '  }')",
+      "classes.push('    padding: 8px 16px;')",
+      "return ['  :where(*) {', '    text-box-trim: trim-both;', '  }']",
+      "held.push('    color-scheme: light dark;')",
+    ],
+    right: [
+      "lines.push('  body {', '    background: var(--colour-page);', '  }')",
+      'lines.push(...block(selector, made, indent))',
+      'held.push(`    ${nameOf(id)}: ${made[id] ?? String()};`)',
+      'const held: readonly string[] = [];',
+    ],
+  },
+}

package/dist/integrity/slopnators/sl_inert_island.ts

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { Slopnator } from '../slopnator.ts'
+import { declaresIsland, here, rowsIn } from './sl_unthreaded.ts'
+import { findTree } from '../../core/tree.ts'
+
+const ROOT = findTree().at
+const TREE = `${findTree().name}/`
+
+function schemaAt(at: string): string | undefined {
+  const path = resolve(ROOT, at)
+  if (!existsSync(path)) return undefined
+  try {
+    return declaresIsland(readFileSync(path, 'utf8'))
+  } catch {
+    return undefined
+  }
+}
+
+export const slopnator: Slopnator = {
+  holds: (_node, at) => {
+    const path = here(at.filename)
+    if (!path.startsWith(TREE)) return false
+
+    let rows
+    try {
+      rows = rowsIn(at.text)
+    } catch {
+      return 'this file cannot be parsed, so the islands it declares were never read and nothing about what they govern was measured'
+    }
+
+    for (const row of rows) {
+      if (row.at === undefined || row.id === undefined) continue
+      const schema = schemaAt(row.at)
+      if (schema === undefined) continue
+      if ((row.governs ?? []).length > 0) continue
+      return (
+        `island "${row.id}" states nothing it governs, so ${schema}IslandSchema is a shape nothing is held to — ` +
+        'no file is the place its kind is declared, which makes every file the place, and the island is inert'
+      )
+    }
+
+    return false
+  },
+  proves: {
+    wrong: [
+      {
+        files: [
+          {
+            at: 'threads/_inert_probe.ts',
+            source:
+              "export const M: Islanding = {\n  declares: [\n    { id: 'entities', at: 'packages/core/spec/src/islands/entities.ts' },\n  ],\n}\n",
+          },
+        ],
+        at: 'threads/_inert_probe.ts',
+      },
+      {
+        files: [
+          {
+            at: 'threads/_inert_probe.ts',
+            source:
+              "export const M: Islanding = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: [] },\n  ],\n}\n",
+          },
+        ],
+        at: 'threads/_inert_probe.ts',
+      },
+    ],
+    right: [
+      {
+        files: [
+          {
+            at: 'threads/_inert_probe.ts',
+            source:
+              "export const M: Islanding = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n",
+          },
+        ],
+        at: 'threads/_inert_probe.ts',
+      },
+      {
+        files: [
+          {
+            at: 'threads/_inert_probe.ts',
+            source: "export const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/thread.ts' },\n  ],\n}\n",
+          },
+        ],
+        at: 'threads/_inert_probe.ts',
+      },
+    ],
+  },
+}