@prestack/thread 0.1.20 → 0.1.22

package/dist/knowledge/attach.ts

@@ -1,327 +0,0 @@
-import type { Attaching } from '../core/attach.ts'
-
-import { SHAPED } from '../core/init.ts'
-import { quoted } from '../core/rows.ts'
-
-const DESCRIBES =
-  'The system that compiles what this repository holds into forms a reader can understand — the glossary first, and every later view of the tree computed rather than written.'
-
-const CONCEPTS =
-  'Every word this framework means something specific by that no declaration coins — its own verbs and the fields they sit in, written by a person because nothing in the tree can state them, and read into the glossary with everything else.'
-
-const CONCEPTS_SOURCE = `import type { Member } from '${SHAPED}'
-
-export interface Concept extends Member {
-  readonly avoid?: readonly string[]
-}
-
-export const CONCEPTS: readonly Concept[] = [
-  {
-    id: 'id',
-    at: '_threads/concepts.ts',
-    describes: 'The word a declaration coins. Every id enters the glossary and the \`describes\` beside it becomes the meaning there, so naming a thing is how this framework acquires vocabulary, and one word carrying two meanings is a contradiction the tree can see.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'wearing',
-    at: '_threads/concepts.ts',
-    describes: 'The relation an app declares between one of its own variants and the elements that may put it on. The framework ships an empty one and an app widens it, so a member named for a variant the app declared compiles and is offered wherever that variant says the element wears it — autocomplete reaching the variants an app added, without the package ever holding a list of them.',
-    version: 1,
-    cites: [
-      { on: '2026-08-25', said: 'Autocomplete should be a framework feature for sure.' },
-      { on: '2026-08-25', said: 'Wearing' },
-    ],
-  },
-  {
-    id: 'dispatching',
-    at: '_threads/concepts.ts',
-    describes: 'The operations this app declares, named wherever something reaches one. The framework ships an empty list and each app widens it, so a name written at a call site is accepted only when this app declared an operation by it.',
-    version: 1,
-    cites: [
-      { on: '2026-08-25', said: 'And make sure the composition can only dispatch existing operations.' },
-      { on: '2026-08-25', said: 'Type only for  both.' },
-    ],
-  },
-  {
-    id: 'holds',
-    at: '_threads/concepts.ts',
-    describes: 'What a sheet contains rather than what it authored. A row here is a named value — a token, a style guide entry, a signal, a mode, a theme — and it carries no address, because a value is not a file and nothing wrote it anywhere. That is what tells it from declares, which is the verb of authorship and admits exactly one owner per address: a hundred values written into one sheet would otherwise read as a hundred authors of it.',
-    version: 1,
-    cites: [
-      { on: '2026-08-26', said: 'No there\\'s just something completely wrong about how you did this, that\\'s why you got this error. The law is not wrong' },
-      { on: '2026-08-26', said: 'holds' },
-    ],
-  },
-  {
-    id: 'at',
-    at: '_threads/concepts.ts',
-    describes: 'Where a declared thing lives, written as a path from the root. It is a string and never an import, which is the whole trick that lets a parent name a child without depending on it: the descent resolves the string when it runs and slopnators in. A path naming a directory threads nothing beneath it.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'describes',
-    at: '_threads/concepts.ts',
-    describes: 'What a thing is and what it solves, to somebody who has not seen it. It is the one piece of prose the tree requires, and the glossary takes each word’s meaning from here, so a sentence that restates the id leaves the word defined by nothing.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'version',
-    at: '_threads/concepts.ts',
-    describes: 'Which one of itself a governing declaration is, so a change to it is a difference a consumer can see rather than a move underneath things already built against it.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'cites',
-    at: '_threads/concepts.ts',
-    describes: 'Whose words permitted a thing to exist, quoted as they were said and dated. It records who decided rather than what was decided, which is \`describes\`, so a declaration nobody asked for is visible as one.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'by',
-    at: '_threads/concepts.ts',
-    describes: 'The command that writes a byproduct. Somewhere across the declarations naming one derived address, one of them owes this, because a generated file whose generator is unnamed cannot be checked against what it should be.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'runs',
-    at: '_threads/concepts.ts',
-    describes: 'The command that proves a byproduct is still the bytes its generator writes. It is the other half of \`by\`: one names what made the file, the other names what catches it drifting.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'declares',
-    at: '_threads/concepts.ts',
-    describes: 'The verb of authorship: a person wrote this file and the declaration is the truth about it. Exactly one may ever declare a given address, because a child with two owners has two answers for where it came from and the tree can give neither.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'derives',
-    at: '_threads/concepts.ts',
-    describes: 'The verb of byproduct: delete the file, run the command again, and identical bytes come back. Many may derive the same kind, because a derivation owns nothing — it owes a \`by\` that writes it and a \`runs\` that proves it.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'seeds',
-    at: '_threads/concepts.ts',
-    describes: 'The verb of scaffold: a machine writes the file out of the tree and a person fills the one field a machine cannot supply. Many may seed the same kind, and it is proved by shape rather than by bytes, because half of what is on disk is somebody’s own writing.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'we need it to start with the threads concepts first, coin the ids and describe what it means.' },
-    ],
-  },
-  {
-    id: 'requires',
-    at: '_threads/concepts.ts',
-    describes: 'Demand that must be met: the thing named has to be there. Demand is not lineage and confers no ownership — needing a thing has never been the same as having been declared by it, which is why it is a word of its own and not a fourth verb.',
-    version: 1,
-    avoid: ['needs'],
-    cites: [
-      { on: '2026-08-19', said: 'Do add to it requires and takes cause these will also be part of it.' },
-      { on: '2026-08-19', said: 'I see no reason to not have this, it\\'s useful.' },
-    ],
-  },
-  {
-    id: 'pass',
-    at: '_threads/concepts.ts',
-    describes: 'One traversal of something, and what it found. The descent from the root is a pass; so is a slopnator over a syntax tree, or over the text of a file. The word names the act and its result together, which is why descending returns a \`Pass\` rather than a report about one.',
-    version: 1,
-    avoid: ['walk'],
-    cites: [
-      { on: '2026-08-20', said: 'Walk is pass.' },
-      { on: '2026-08-20', said: 'walk is pass. fix it.' },
-    ],
-  },
-  {
-    id: 'slopnator',
-    at: '_threads/concepts.ts',
-    describes: 'The code that finds what a rule refuses — one per rule, resolved from the rule\\'s id, in one of three kinds: a pass over a syntax tree, a pass over a file\\'s text, or a command whose output is read.',
-    version: 1,
-    avoid: ['walk'],
-    cites: [
-      { on: '2026-08-19', said: 'I still don\\'t get why it\\'s called walk. Seems bizarre. Smells like slop' },
-      { on: '2026-08-19', said: 'Then put walk in the concepts (not the repo\\'s, just the package, fuck the repo).' },
-    ],
-  },
-  {
-    id: 'takes',
-    at: '_threads/concepts.ts',
-    describes: 'Demand that may go unmet: the thing named is used when it is there. It is \`requires\` without the refusal, so something optional is stated rather than discovered by reading what happens when it is missing.',
-    version: 1,
-    cites: [
-      { on: '2026-08-19', said: 'Do add to it requires and takes cause these will also be part of it.' },
-      { on: '2026-08-19', said: 'I see no reason to not have this, it\\'s useful.' },
-    ],
-  },
-  {
-    id: 'threaded',
-    at: '_threads/concepts.ts',
-    describes: 'What a file is once some parent names it in \`declares\`, \`derives\` or \`seeds\`. A file is threaded or it is not, and the record of which parent did it and by which verb is a \`Threading\`. The framework is named for this, so nothing here claims, owns or registers anything — whatever the descent never reaches is unthreaded, and that absence is the finding.',
-    version: 1,
-    avoid: ['claim', 'claims', 'claimed'],
-    cites: [
-      { on: '2026-08-20', said: 'Claim I don\\'t fukcing know what is. We have threads, threaded, these are the fucking names. The framework is named for this damn it.' },
-      { on: '2026-08-20', said: 'add whatever you need to add to put it in your head that it\\'s threaded not claimed.' },
-    ],
-  },
-  {
-    id: 'attribute',
-    at: '_threads/concepts.ts',
-    describes: 'One typed thing an entity holds: which kind of value it is, which refinement of that kind, and the bounds on it. It is the smallest thing a provider can be told to keep, and an attribute nothing declares is one nobody can account for.',
-    version: 1,
-    cites: [
-      { on: '2026-08-21', said: 'Value and Invariant' },
-      { on: '2026-08-28', said: 'The concept takes a different word' },
-    ],
-  },
-  {
-    id: 'invariant',
-    at: '_threads/concepts.ts',
-    describes: 'What is true of a thing no matter who is asking. It is written in the same condition language a grant uses and told apart from one mechanically rather than by taste: an invariant that reaches for the actor is true for some callers and false for others, so it is a grant somebody filed in the wrong place.',
-    version: 1,
-    cites: [
-      { on: '2026-08-21', said: 'Value and Invariant' },
-    ],
-  },
-  {
-    id: 'grant',
-    at: '_threads/concepts.ts',
-    describes: 'One statement of who may do which verbs to which entity, narrowed to some of its values, under a condition the row must meet. A grant is a way in and nothing else: absence is refusal, and two standing together admit more than either alone.',
-    version: 1,
-    cites: [
-      { on: '2026-08-21', said: 'Invariant + Grant' },
-      { on: '2026-08-21', said: 'who can, when, where, how much' },
-    ],
-  },
-  {
-    id: 'target',
-    at: '_threads/concepts.ts',
-    describes: 'A declared destination — somewhere this app sends something or keeps something — named so that nothing ever reaches one it did not declare. It is one word across the framework and not two: an operation calls out to a target over the network, an entity is kept in a target, and both are the same idea of a place named before it is reached. What each package needs beyond that differs, and neither borrows the other\\'s shape: a target data keeps things in carries what it is on the prefix of its id, because what it can be made to enforce decides what may be written for it, and a declaration it cannot hold is refused where it was written rather than emitted as something that reads like enforcement and is not.',
-    version: 1,
-    cites: [
-      { on: '2026-08-29', said: 'Target is not two things. Target is a destination, either in operations or in data.' },
-      { on: '2026-08-29', said: 'it seems like this is the thing that decides what\\'s going to server and whats local, that it?' },
-    ],
-  },
-  {
-    id: 'setting',
-    at: '_threads/concepts.ts',
-    describes: 'One property a material or a variant sets, and where its value comes from: a value the style guide holds, named outright, or a token asked for one, arguments and all — never both together. It is the row both compose from, so a material’s resting look, its states, and a variant’s states are one shape instead of three that only resemble each other.',
-    version: 1,
-    cites: [],
-  },
-  {
-    id: 'token',
-    at: '_threads/concepts.ts',
-    describes: 'A sort of variable an app may have, named and never valued — colour, space, shadow. It says such a variable can exist; the style guide says which ones there are and what each holds. Where the thing is better stated as a rule than as a list, the token carries that rule and a style guide row hands it arguments instead of a value. An app adds one to bring a new sort of variable into being, and may not remove what the framework put there.',
-    version: 1,
-    cites: [],
-  },
-]
-`
-
-const SEEDED = {
-  attaches: ['@prestack/thread/derivation/attach'] as const,
-  id: 'knowledge',
-  declares: [
-    '    {',
-    '      id: \'knowledge\',',
-    '      at: \'_threads/knowledge.ts\',',
-    '      describes: \'The system that compiles what this repository holds into forms a reader can understand — the glossary first, and every later view of the tree computed rather than written.\',',
-    '      version: 1,',
-    '    },',
-  ].join('\n'),
-}
-
-const SHIPPED: readonly { readonly into: string; readonly list: string; readonly id: string; readonly source: string }[] = [
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'glossary-generator',
-    source: "  {\n    id: 'glossary-generator',\n    at: 'node_modules/@prestack/thread/dist/knowledge/generators/glossary.js',\n    describes: 'The generator of the glossary — it descends the tree, takes the `describes` from the row that coins each word, and writes them in the order the descent reaches them.',\n    version: 1,\n    by: 'thread glossary',\n    runs: 'thread glossary --check',\n  },",
-  },
-  {
-    into: 'derivation.ts',
-    list: 'GENERATORS',
-    id: 'docs-generator',
-    source: "  {\n    id: 'docs-generator',\n    at: 'node_modules/@prestack/thread/dist/knowledge/generators/docsgen.js',\n    describes: 'The writer of the page stating what this app declares — it descends the tree once and writes every node, everything each one declares and derives, and the command that writes each of those, with the sentence the row itself states. It moved here from the package that had operations in it, where it could only ever have documented operations: a package stating what another package declares would be one package authoring another\\'s. Where an operation has been run, the count of recorded runs is taken from the trials file by path if that file is there, so what proves an operation survives without anything here depending on the package that produces it.',\n    version: 1,\n    by: 'thread docs',\n    runs: 'thread docs --check',\n  },",
-  },
-]
-export const ATTACH: Attaching = {
-  attaches: SEEDED.attaches,
-  id: SEEDED.id,
-  declares: SEEDED.declares,
-  writes: [
-    {
-      file: 'knowledge.ts',
-      source: [
-        `import type { Threaded } from '${SHAPED}'`,
-        '',
-        'export const KNOWLEDGE: Threaded = {',
-        "  id: 'knowledge',",
-        "  at: '_threads/knowledge.ts',",
-        `  describes: ${quoted(DESCRIBES)},`,
-        '  version: 1,',
-        '  declares: [',
-        '    {',
-        "      id: 'concepts',",
-        "      at: '_threads/concepts.ts',",
-        `      describes: ${quoted(CONCEPTS)},`,
-        '    },',
-        '  ],',
-        '  derives: [',
-        '    {',
-        "      id: 'glossary',",
-        "      at: '_threads/glossary.ts',",
-        "      describes: 'Every word this repository coins and what it means — one row per word, taken from the `describes` on the row that declares it, ordered by the descent, so the file is the tree read as vocabulary rather than a list kept beside it.',",
-        '      version: 1,',
-        "      by: 'thread glossary',",
-        "      runs: 'thread glossary --check',",
-        '    },',
-
-        '    {',
-        "      id: 'docs',",
-        "      at: 'docs.md',",
-        "      describes: 'What this app declares, as a page: every node, what it declares, what it derives and what writes each of those, with the sentence each row states about itself. It is the glossary\\'s other half — that one says what every coined word means, this one says what every row is — and both are the same descent read twice, so a section going out of date is a bug rather than a chore.',",
-        '      version: 1,',
-        "      by: 'thread docs',",
-        "      runs: 'thread docs --check',",
-        '    },',
-        '  ],',
-        '}',
-        '',
-      ].join('\n'),
-    },
-    {
-      file: 'concepts.ts',
-      source: CONCEPTS_SOURCE,
-    },
-  ],
-  rows: SHIPPED,
-}

package/dist/knowledge/generators/docsgen.ts

@@ -1,186 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { resolve } from 'node:path'
-import { argv, stderr, stdout } from 'node:process'
-
-import { exit } from '../../core/invoked.ts'
-import { ROOT, descend, type Pass, type Row } from '../../core/descend.ts'
-import { forbids, runChecker, type Finding } from '../../core/finding.ts'
-import { agentInstructions } from '../../integrity/lint.ts'
-
-const AT = 'docs.md'
-
-const CHECKING = argv.includes('--check')
-
-const SHOWING = argv.includes('--show')
-
-const TRIALS_AT = 'operations/_trials.json'
-
-function refuse(why: string): never {
-  stderr.write(`docs: ${why}\n`)
-  exit(1)
-}
-
-const text = (value: unknown): string | undefined => (typeof value === 'string' && value !== '' ? value : undefined)
-
-const said = (one: Row): string => text(one.describes) ?? '_no `describes` — this row says nothing about itself._'
-
-const pass = await descend()
-
-const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0]
-if (stopped !== undefined) {
-  refuse(
-    'the descent is broken, so this would state a tree that is only partly known and read afterwards as the whole of it — ' +
-      `${stopped.detail} (${stopped.file ?? ''})`,
-  )
-}
-
-const PATH = resolve(ROOT, AT)
-
-interface Ran {
-  readonly operation?: string
-  readonly scenario?: string
-  readonly ok?: boolean
-}
-
-const proven = (): ReadonlyMap<string, number> => {
-  const found = new Map<string, number>()
-  const at = resolve(ROOT, TRIALS_AT)
-  if (!existsSync(at)) return found
-  try {
-    const held = JSON.parse(readFileSync(at, 'utf8')) as readonly Ran[]
-    for (const one of held) {
-      const which = text(one.operation)
-      if (which === undefined) continue
-      found.set(which, (found.get(which) ?? 0) + 1)
-    }
-  } catch {
-    return found
-  }
-  return found
-}
-
-function grouped(held: Pass): ReadonlyMap<string, readonly { readonly list: string; readonly row: Row }[]> {
-  const found = new Map<string, { readonly list: string; readonly row: Row }[]>()
-  for (const threadings of held.threaded.values()) {
-    for (const one of threadings) {
-      const kept = found.get(one.by) ?? []
-      kept.push({ list: one.list, row: one.row })
-      found.set(one.by, kept)
-    }
-  }
-  return found
-}
-
-const under = grouped(pass)
-const trials = proven()
-
-const named = (one: Row): string => text(one.id) ?? text(one.at) ?? '(unnamed)'
-
-const line = (one: { readonly list: string; readonly row: Row }): string => {
-  const row = one.row
-  const where = text(row.at)
-  const by = text(row.by)
-  const runs = text(row.runs)
-  const ran = trials.get(named(row))
-
-  return [
-    `- **${named(row)}**${where === undefined ? '' : ` — \`${where}\``}`,
-    `  ${said(row)}`,
-    ...(by === undefined ? [] : [`  Written by \`${by}\`${runs === undefined ? '' : `, checked by \`${runs}\``}.`]),
-    ...((row.requires ?? []).length === 0 ? [] : [`  Requires ${(row.requires ?? []).map((each) => `\`${each}\``).join(', ')}.`]),
-    ...((row.takes ?? []).length === 0 ? [] : [`  Takes ${(row.takes ?? []).map((each) => `\`${each}\``).join(', ')}.`]),
-
-    ...(ran === undefined ? [] : [`  Proved by ${String(ran)} recorded run(s).`]),
-  ].join('\n')
-}
-
-const words = [...pass.coined].sort(([one], [two]) => (one < two ? -1 : 1))
-
-const threadedRows = new Set([...pass.threaded.values()].flat().map((one) => one.row))
-const loose = [...pass.stated.values()].filter((one) => !threadedRows.has(one))
-const commands = [...pass.derived.values(), ...[...under.values()].flat().map((one) => one.row), ...loose]
-  .filter((one) => text(one.by)?.startsWith('thread ') === true)
-  .reduce((found, one) => found.set(text(one.by) as string, one), new Map<string, Row>())
-
-const sections = [...under.keys()].sort()
-
-const refused = agentInstructions()
-
-const page = [
-  '<!-- GENERATED by `thread docs` from what this app declares — do not edit by hand.',
-  '     Every sentence here is the `describes` on a row. To change one, change the row. -->',
-  '',
-  '# What this app declares',
-  '',
-  `${String(pass.declarations)} declaration(s) over ${String(pass.rows)} row(s), read from the tree by the same descent`,
-  'every generator here reads. This page is rewritten whenever a package is attached and whenever a',
-  'command writes a row, so a section that is out of date is a bug rather than a chore.',
-  '',
-  '## Commands',
-  '',
-  ...(commands.size === 0
-    ? ['_nothing here declares a command yet._']
-    : [...commands.entries()]
-        .sort(([one], [two]) => (one < two ? -1 : 1))
-        .map(([word, one]) => `- \`${word}\` — ${said(one)}`)),
-  '',
-  '## What the build refuses',
-  '',
-  'Every rule below stops a build outright. Each line pairs the code it rejects with the code it requires instead.',
-  '',
-  ...(refused.length === 0
-    ? ['_nothing here refuses anything yet._']
-    : refused.map((rule) => `- ${rule}`)),
-  '',
-  ...sections.flatMap((node) => {
-    const own = pass.stated.get(node) ?? pass.derived.get(node)
-    const kept = under.get(node) ?? []
-    const declares = kept.filter((one) => one.list === 'declares')
-    const derives = kept.filter((one) => one.list === 'derives')
-    const seeds = kept.filter((one) => one.list === 'seeds')
-    return [
-      `## ${node}`,
-      '',
-      ...(own === undefined ? [] : [said(own), '']),
-      ...(declares.length === 0 ? [] : ['### What it declares', '', ...declares.map(line), '']),
-      ...(derives.length === 0 ? [] : ['### What it derives', '', ...derives.map(line), '']),
-      ...(seeds.length === 0 ? [] : ['### What it seeds', '', ...seeds.map(line), '']),
-    ]
-  }),
-  '## Every word this app coins',
-  '',
-  ...(words.length === 0
-    ? ['_nothing here coins a word yet._']
-    : words.map(([word, held]) => `- **${word}** — ${held.said[0] ?? '_no meaning stated_'}`)),
-  '',
-].join('\n')
-
-if (SHOWING) {
-  stdout.write(page)
-  exit(0)
-}
-
-if (CHECKING) {
-  const findings: Finding[] = []
-  const held = existsSync(PATH) ? readFileSync(PATH, 'utf8') : undefined
-  if (held === undefined) {
-    findings.push({
-      detail: `${AT} is not there, and this app declares it`,
-      instead: `Run \`thread docs\`. Nothing writes this page by hand — it is what the tree says, read back.`,
-      file: AT,
-      severity: 'forbidden',
-    })
-  } else if (held !== page) {
-    findings.push({
-      detail: `${AT} states something other than what this tree declares`,
-      instead: `Run \`thread docs\`. A sentence here is the \`describes\` on a row — to change one, change the row.`,
-      file: AT,
-      severity: 'forbidden',
-    })
-  }
-  runChecker('docs', findings, `${AT} states every row this app declares, ${String(pass.rows)} of them`)
-  exit(findings.length === 0 ? 0 : 1)
-}
-
-writeFileSync(PATH, page, 'utf8')
-stdout.write(`docs: wrote ${AT} — ${String(sections.length)} node(s), ${String(commands.size)} command(s), ${String(words.length)} word(s).\n`)

package/dist/knowledge/generators/glossary.ts

@@ -1,73 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { dirname, relative, resolve } from 'node:path'
-import { argv, stderr, stdout } from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-import { exit } from '../../core/invoked.ts'
-import { ROOT, descend } from '../../core/descend.ts'
-import { forbids, runChecker, type Finding } from '../../core/finding.ts'
-
-function refuse(why: string): never {
-  stderr.write(`glossary: ${why}\n`)
-  exit(1)
-}
-
-function text(value: unknown): string | undefined {
-  return typeof value === 'string' && value !== '' ? value : undefined
-}
-
-function quote(value: string): string {
-  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
-}
-
-const pass = await descend()
-
-const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0]
-if (stopped !== undefined) {
-  refuse(`the descent is broken, so the harvest is short and writing it would delete words that exist — ${stopped.detail} (${stopped.file ?? ''})`)
-}
-
-const SELF = pass.derived.get('glossary')
-if (SELF === undefined) {
-  refuse('nothing in the tree derives `glossary`, so this script has no declaration saying what it writes or where')
-}
-
-const AT = text(SELF.at) ?? refuse('the `glossary` row names no `at`, so where the glossary lands is unstated')
-const PATH = resolve(ROOT, AT)
-
-const toward = relative(dirname(PATH), fileURLToPath(new URL('../glossary.ts', import.meta.url))).split('\\').join('/')
-
-const shape = toward.startsWith('.') ? toward : `./${toward}`
-
-const words = [...pass.coined]
-
-function row([word, held]: (typeof words)[number]): string {
-  const from = held.from.map(quote).join(', ')
-  return `  { id: ${quote(word)}, under: ${quote(held.under)}, from: [${from}], means: ${quote(held.said[0] ?? '')} },`
-}
-
-const content = `import type { Glossary } from '${shape}'
-
-export const GLOSSARY: Glossary[] = [
-${words.map(row).join('\n')}
-]
-`
-
-if (argv.includes('--check')) {
-  const findings: Finding[] = []
-  const current = existsSync(PATH) ? readFileSync(PATH, 'utf8') : ''
-
-  if (current !== content) {
-    findings.push({
-      file: AT,
-      detail: 'is not what the slopnator from the root derives',
-      instead: `run \`${text(SELF.by) ?? 'thread glossary'}\` and commit what it writes. Never edit this file — a meaning lives on the row that coins the word, and an edit here is a change to that row somebody skipped`,
-    })
-  }
-
-  runChecker('glossary', findings, `${String(words.length)} word(s) coined over ${String(pass.declarations)} declaration(s)`)
-  exit(findings.length === 0 ? 0 : 1)
-}
-
-writeFileSync(PATH, content)
-stdout.write(`glossary: wrote ${AT} — ${String(words.length)} word(s).\n`)

package/dist/knowledge/glossary.ts

@@ -1,6 +0,0 @@
-export interface Glossary {
-  readonly id: string
-  readonly under: string
-  readonly from: readonly string[]
-  readonly means: string
-}