@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/sweep.js

@@ -1,14 +1,13 @@
-import { execFileSync } from 'node:child_process';
-import { attached, existsSync, readFileSync, readdirSync } from "../core/files.js";
+import { starts } from '../integrations/cli.js';
+import { attached, existsSync, readFileSync, readdirSync } from '../integrations/disk.js';
 import { join } from 'node:path';
-import { stdout } from 'node:process';
-import { descend } from "../core/descend.js";
-import { runChecker } from "../core/finding.js";
-import { exit, invoked } from "../core/invoked.js";
+import { argv, stdout } from 'node:process';
+import { runChecker } from '../core/finding.js';
+import { exit, invoked } from '../core/invoked.js';
 import { parser } from 'typescript-eslint';
-import { CONSTRAINTS } from "./constraint.js";
-import { NOT_WRITTEN, ROOT, governs, load, reads, rules, slopnatorName, sweeps, visits } from "./slopnator.js";
-import { deriveTrials, runTrials } from "./generators/trial.js";
+import { CONSTRAINTS } from './constraint.js';
+import { NOT_WRITTEN, ROOT, derivedHere, governs, load, proofsOf, reads, rules, slopnatorName, subject, sweeps, visits } from './slopnator.js';
+import { crossed, deriveTrials, runTrials } from './generators/trial.js';
 const PARSEABLE = /\.(ts|tsx|mts|cts|mjs|cjs|js|jsx)$/;
 function tree(text) {
     const read = (jsx) => parser.parseForESLint(text, {
@@ -57,6 +56,23 @@ export function visit(root, on, each) {
     };
     step(root);
 }
+const blank = (said) => said.replace(/[^\n]/g, ' ');
+const sourcesIn = (one) => typeof one === 'string'
+    ? [one]
+    : one.files.flatMap((each) => (typeof each.source === 'string' ? [each.source] : []));
+function without(text, rule, slopnators) {
+    let said = text;
+    for (const proof of proofsOf(rule, slopnators).wrong) {
+        for (const source of sourcesIn(proof)) {
+            for (const one of [source, source.trim()]) {
+                if (one === '')
+                    continue;
+                said = said.replaceAll(one, blank(one));
+            }
+        }
+    }
+    return said;
+}
 const ELSEWHERE = new Set(['node_modules', '.git']);
 function ignoredIn(root) {
     const at = join(root, '.gitignore');
@@ -67,28 +83,12 @@ function ignoredIn(root) {
         .map((line) => line.trim().replace(/^\//, '').replace(/\/$/, ''))
         .filter((line) => line !== '' && !line.startsWith('#') && !line.includes('*') && !line.startsWith('!')));
 }
-function authored() {
-    const found = new Set();
-    try {
-        for (const [at, threadings] of descend().threaded) {
-            if (threadings.some((one) => one.list === 'derives' && (one.row.by ?? one.row.runs) !== undefined))
-                found.add(at);
-        }
-    }
-    catch {
-    }
-    return found;
-}
 export function tracked(root) {
-    const derived = authored();
-    const mine = (one) => !derived.has(one);
+    const derived = derivedHere();
+    const mine = (one) => derived?.has(one) !== true;
     try {
-        const listed = execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
-            cwd: root,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        })
-            .split('\n')
+        const listed = starts('git', ['ls-files', '--cached', '--others', '--exclude-standard'], { at: root })
+            .out.split('\n')
             .filter(Boolean);
         if (!attached() && listed.length > 0) {
             return [...new Set(listed)].filter((one) => existsSync(join(root, one)) && mine(one)).sort();
@@ -123,10 +123,20 @@ export function sweep(root, all, slopnators, files) {
         .filter((one) => one.slopnator !== undefined && visits(one.slopnator));
     const findings = [];
     let swept = 0;
+    const spent = new Map();
+    const timed = (rule, work) => {
+        const began = Date.now();
+        try {
+            return work();
+        }
+        finally {
+            spent.set(rule, (spent.get(rule) ?? 0) + Date.now() - began);
+        }
+    };
     const met = new Set();
     for (const file of files) {
-        const reading = readers.filter((one) => governs(one.rule, file));
-        const walking = walkers.filter((one) => governs(one.rule, file));
+        const reading = readers.filter((one) => subject(one.rule) && governs(one.rule, file));
+        const walking = walkers.filter((one) => subject(one.rule) && governs(one.rule, file));
         for (const one of reading)
             met.add(one.rule.id);
         for (const one of walking)
@@ -142,12 +152,12 @@ export function sweep(root, all, slopnators, files) {
         }
         swept += 1;
         for (const { rule, slopnator } of reading) {
-            const held = slopnator.holds(undefined, {
+            const held = timed(rule.id, () => slopnator.holds(undefined, {
                 filename: file,
-                text,
+                text: without(text, rule, slopnators),
                 ancestors: () => [],
                 comments: () => [],
-            });
+            }));
             if (held === false || held === NOT_WRITTEN)
                 continue;
             findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) });
@@ -177,7 +187,7 @@ export function sweep(root, all, slopnators, files) {
                 });
                 continue;
             }
-            visit(ast, on, (node, ancestors) => {
+            timed(rule.id, () => visit(ast, on, (node, ancestors) => {
                 const held = slopnator.holds(node, {
                     filename: file,
                     text,
@@ -187,14 +197,14 @@ export function sweep(root, all, slopnators, files) {
                 if (held === false || held === NOT_WRITTEN)
                     return;
                 findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) });
-            });
+            }));
         }
     }
     for (const rule of all) {
         const slopnator = slopnators.get(slopnatorName(rule.id));
         if (slopnator === undefined || reads(slopnator))
             continue;
-        for (const found of slopnator.checks(root))
+        for (const found of timed(rule.id, () => slopnator.checks(root)))
             findings.push({ rule: rule.id, file: '', found });
     }
     const unrun = all.filter((rule) => slopnators.get(slopnatorName(rule.id)) === undefined).map((rule) => rule.id);
@@ -207,6 +217,7 @@ export function sweep(root, all, slopnators, files) {
         unrun,
         unmet,
         linted,
+        spent,
         rules: readers.length +
             walkers.length +
             all.filter((rule) => {
@@ -216,17 +227,54 @@ export function sweep(root, all, slopnators, files) {
     };
 }
 if (invoked(import.meta.url)) {
-    const governing = [...CONSTRAINTS, ...((await rules()) ?? [])];
+    const began = Date.now();
+    const declared = [...CONSTRAINTS, ...((await rules()) ?? [])];
+    let only;
+    let flagged = false;
+    for (const one of argv) {
+        if (flagged) {
+            only = one;
+            break;
+        }
+        if (one === '--only')
+            flagged = true;
+    }
+    let governing = [];
+    for (const one of declared) {
+        const id = one['id'];
+        if (only === undefined || id === only || slopnatorName(id) === only)
+            governing = [...governing, one];
+    }
+    if (governing[0] === undefined) {
+        runChecker('sweep', [
+            {
+                file: '',
+                detail: 'this tree declares no rule called ' + String(only),
+                instead: 'name a rule by its id, or by the slopnator beside it — `thread rules` lists both. Running all of them while ' +
+                    'saying one was asked for is a green tick over a sweep nobody asked for, so nothing was swept',
+            },
+        ], '');
+        exit(1);
+    }
     const slopnators = await load(ROOT, governing);
     const named = new Map(governing.map((rule) => [rule.id, rule]));
+    const loaded = Date.now();
     const run = sweep(ROOT, governing, slopnators, tracked(ROOT));
-    const { default: plugin } = await import("./lint.js");
-    const proving = runTrials(deriveTrials(governing, slopnators).trials, governing, plugin.rules, parser, slopnators);
-    const unproven = proving.outcomes.filter((one) => !one.passed);
+    const walked = Date.now();
+    const { default: plugin } = await import('./lint.js');
+    const derived = deriveTrials(governing, slopnators).trials;
+    const proving = runTrials(derived, governing, plugin.rules, parser, slopnators);
+    const proved = Date.now();
+    const crossing = new Map();
+    const unproven = [
+        ...proving.outcomes.filter((one) => !one.passed),
+        ...crossed(derived, declared, plugin.rules, parser, await load(ROOT, declared), crossing),
+    ];
+    const done = Date.now();
     const failing = new Map();
     for (const one of unproven) {
         const held = failing.get(one.rule) ?? [];
-        held.push(`      ${one.failures.join('; ')}`);
+        held.push(`      ${one.id} — ${one.failures.join('; ')}`);
         failing.set(one.rule, held);
     }
     const warned = new Set();
@@ -268,6 +316,21 @@ if (invoked(import.meta.url)) {
         `${String(run.linted.length)} of them reading a syntax tree, and ${String(proving.passed)} of ${String(proving.outcomes.length)} rule trial(s) passed, ${String(proving.measured)} measured` +
         `${run.unrun.length === 0 ? '' : `, ${String(run.unrun.length)} that DID NOT RUN AT ALL`}` +
         `${run.unmet.length === 0 ? '' : `, and ${String(run.unmet.length)} that governed no file here and so measured nothing: ${run.unmet.join(', ')}`}`);
+    const seconds = (ms) => String(Math.round(ms / 1000)) + ' s';
+    const slowest = (spent) => [...spent.entries()]
+        .sort((one, two) => two[1] - one[1])
+        .slice(0, 3)
+        .map(([rule, ms]) => rule + ' ' + seconds(ms))
+        .join(', ');
+    const own = new Map(run.spent);
+    for (const [rule, ms] of proving.spent)
+        own.set(rule, (own.get(rule) ?? 0) + ms);
+    stdout.write('sweep: it took ' + seconds(done - began) + '. Loading the rules took ' + seconds(loaded - began) +
+        ', reading the files in this tree ' + seconds(walked - loaded) +
+        ', running each rule on its own examples ' + seconds(proved - walked) +
+        ', and holding what each rule recommends against every other rule ' + seconds(done - proved) +
+        '. Slowest on their own files and examples: ' + slowest(own) +
+        '. Slowest to hold against the rest: ' + slowest(crossing) + '.\n');
     const forbidding = findings.length - run.findings.filter((one) => named.get(one.rule)?.severity === 'warning').length;
     if (forbidding > 0)
         exit(1);

package/dist/integrity/sweep.ts

@@ -1,19 +1,18 @@
-import { execFileSync } from 'node:child_process'
-import { attached, existsSync, readFileSync, readdirSync } from '../core/files.ts'
+import { starts } from '../integrations/cli.ts'
+import { attached, existsSync, readFileSync, readdirSync } from '../integrations/disk.ts'
 import { join } from 'node:path'
-import { stdout } from 'node:process'
+import { argv, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
 
-import { descend } from '../core/descend.ts'
 import { runChecker, type Finding } from '../core/finding.ts'
 import { exit, invoked } from '../core/invoked.ts'
 
 import { parser } from 'typescript-eslint'
 
-import { CONSTRAINTS, type Constraint } from './constraint.ts'
-import { NOT_WRITTEN, ROOT, governs, load, reads, rules, slopnatorName, sweeps, visits, type Reading, type Slopnator, type Spoken, type Visiting } from './slopnator.ts'
+import { CONSTRAINTS, type Constraint, type Proof } from './constraint.ts'
+import { NOT_WRITTEN, ROOT, derivedHere, governs, load, proofsOf, reads, rules, slopnatorName, subject, sweeps, visits, type Reading, type Slopnator, type Spoken, type Visiting } from './slopnator.ts'
 import { ruleMessage } from './lint.ts'
-import { deriveTrials, runTrials } from './generators/trial.ts'
+import { crossed, deriveTrials, runTrials } from './generators/trial.ts'
 
 const PARSEABLE = /\.(ts|tsx|mts|cts|mjs|cjs|js|jsx)$/
 
@@ -65,6 +64,26 @@ export function visit(root: Node, on: ReadonlySet<string>, each: (node: Node, an
   step(root)
 }
 
+const blank = (said: string): string => said.replace(/[^\n]/g, ' ')
+
+const sourcesIn = (one: Proof): readonly string[] =>
+  typeof one === 'string'
+    ? [one]
+    : one.files.flatMap((each) => (typeof each.source === 'string' ? [each.source] : []))
+
+function without(text: string, rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): string {
+  let said = text
+  for (const proof of proofsOf(rule, slopnators).wrong) {
+    for (const source of sourcesIn(proof)) {
+      for (const one of [source, source.trim()]) {
+        if (one === '') continue
+        said = said.replaceAll(one, blank(one))
+      }
+    }
+  }
+  return said
+}
+
 export interface Caught {
   readonly rule: string
   readonly file: string
@@ -84,30 +103,14 @@ function ignoredIn(root: string): ReadonlySet<string> {
   )
 }
 
-function authored(): ReadonlySet<string> {
-  const found = new Set<string>()
-  try {
-    for (const [at, threadings] of descend().threaded) {
-      if (threadings.some((one) => one.list === 'derives' && (one.row.by ?? one.row.runs) !== undefined)) found.add(at)
-    }
-  } catch {
-
-  }
-  return found
-}
-
 export function tracked(root: string): readonly string[] {
-  const derived = authored()
-  const mine = (one: string): boolean => !derived.has(one)
+  const derived = derivedHere()
+  const mine = (one: string): boolean => derived?.has(one) !== true
 
   try {
 
-    const listed = execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
-      cwd: root,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-      .split('\n')
+    const listed = starts('git', ['ls-files', '--cached', '--others', '--exclude-standard'], { at: root })
+      .out.split('\n')
       .filter(Boolean)
     if (!attached() && listed.length > 0) {
       return [...new Set(listed)].filter((one) => existsSync(join(root, one)) && mine(one)).sort()
@@ -146,6 +149,7 @@ export function sweep(
   readonly unrun: readonly string[]
   readonly unmet: readonly string[]
   readonly linted: readonly string[]
+  readonly spent: ReadonlyMap<string, number>
 } {
   const readers = all
     .map((rule) => ({ rule, slopnator: slopnators.get(slopnatorName(rule.id)) }))
@@ -157,12 +161,21 @@ export function sweep(
 
   const findings: Caught[] = []
   let swept = 0
+  const spent = new Map<string, number>()
+  const timed = <T>(rule: string, work: () => T): T => {
+    const began = Date.now()
+    try {
+      return work()
+    } finally {
+      spent.set(rule, (spent.get(rule) ?? 0) + Date.now() - began)
+    }
+  }
 
   const met = new Set<string>()
 
   for (const file of files) {
-    const reading = readers.filter((one) => governs(one.rule, file))
-    const walking = walkers.filter((one) => governs(one.rule, file))
+    const reading = readers.filter((one) => subject(one.rule) && governs(one.rule, file))
+    const walking = walkers.filter((one) => subject(one.rule) && governs(one.rule, file))
     for (const one of reading) met.add(one.rule.id)
     for (const one of walking) met.add(one.rule.id)
     if (reading.length === 0 && walking.length === 0) continue
@@ -176,12 +189,14 @@ export function sweep(
     swept += 1
 
     for (const { rule, slopnator } of reading) {
-      const held = slopnator.holds(undefined, {
-        filename: file,
-        text,
-        ancestors: () => [],
-        comments: () => [],
-      })
+      const held = timed(rule.id, () =>
+        slopnator.holds(undefined, {
+          filename: file,
+          text: without(text, rule, slopnators),
+          ancestors: () => [],
+          comments: () => [],
+        }),
+      )
       if (held === false || held === NOT_WRITTEN) continue
       findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) })
     }
@@ -213,7 +228,7 @@ export function sweep(
         })
         continue
       }
-      visit(ast, on, (node, ancestors) => {
+      timed(rule.id, () => visit(ast, on, (node, ancestors) => {
         const held = slopnator.holds(node, {
           filename: file,
           text,
@@ -222,14 +237,14 @@ export function sweep(
         })
         if (held === false || held === NOT_WRITTEN) return
         findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) })
-      })
+      }))
     }
   }
 
   for (const rule of all) {
     const slopnator = slopnators.get(slopnatorName(rule.id))
     if (slopnator === undefined || reads(slopnator)) continue
-    for (const found of slopnator.checks(root)) findings.push({ rule: rule.id, file: '', found })
+    for (const found of timed(rule.id, () => slopnator.checks(root))) findings.push({ rule: rule.id, file: '', found })
   }
 
   const unrun = all.filter((rule) => slopnators.get(slopnatorName(rule.id)) === undefined).map((rule) => rule.id)
@@ -243,6 +258,7 @@ export function sweep(
     unrun,
     unmet,
     linted,
+    spent,
     rules:
       readers.length +
       walkers.length +
@@ -254,19 +270,59 @@ export function sweep(
 }
 
 if (invoked(import.meta.url)) {
-  const governing = [...CONSTRAINTS, ...((await rules()) ?? [])]
+  const began = Date.now()
+  const declared = [...CONSTRAINTS, ...((await rules()) ?? [])]
+  let only: string | undefined
+  let flagged = false
+  for (const one of argv) {
+    if (flagged) {
+      only = one
+      break
+    }
+    if (one === '--only') flagged = true
+  }
+  let governing: readonly Constraint[] = []
+  for (const one of declared) {
+    const id = one['id']
+    if (only === undefined || id === only || slopnatorName(id) === only) governing = [...governing, one]
+  }
+  if (governing[0] === undefined) {
+    runChecker(
+      'sweep',
+      [
+        {
+          file: '',
+          detail: 'this tree declares no rule called ' + String(only),
+          instead:
+            'name a rule by its id, or by the slopnator beside it — `thread rules` lists both. Running all of them while ' +
+            'saying one was asked for is a green tick over a sweep nobody asked for, so nothing was swept',
+        },
+      ],
+      '',
+    )
+    exit(1)
+  }
   const slopnators = await load(ROOT, governing)
   const named = new Map(governing.map((rule) => [rule.id, rule]))
+  const loaded = Date.now()
   const run = sweep(ROOT, governing, slopnators, tracked(ROOT))
+  const walked = Date.now()
 
   const { default: plugin } = await import('./lint.ts')
-  const proving = runTrials(deriveTrials(governing, slopnators).trials, governing, plugin.rules, parser, slopnators)
-  const unproven = proving.outcomes.filter((one) => !one.passed)
+  const derived = deriveTrials(governing, slopnators).trials
+  const proving = runTrials(derived, governing, plugin.rules, parser, slopnators)
+  const proved = Date.now()
+  const crossing = new Map<string, number>()
+  const unproven = [
+    ...proving.outcomes.filter((one) => !one.passed),
+    ...crossed(derived, declared, plugin.rules, parser, await load(ROOT, declared), crossing),
+  ]
+  const done = Date.now()
 
   const failing = new Map<string, string[]>()
   for (const one of unproven) {
     const held = failing.get(one.rule) ?? []
-    held.push(`      ${one.failures.join('; ')}`)
+    held.push(`      ${one.id} — ${one.failures.join('; ')}`)
     failing.set(one.rule, held)
   }
 
@@ -315,6 +371,23 @@ if (invoked(import.meta.url)) {
       `${run.unrun.length === 0 ? '' : `, ${String(run.unrun.length)} that DID NOT RUN AT ALL`}` +
       `${run.unmet.length === 0 ? '' : `, and ${String(run.unmet.length)} that governed no file here and so measured nothing: ${run.unmet.join(', ')}`}`,
   )
+  const seconds = (ms: number): string => String(Math.round(ms / 1000)) + ' s'
+  const slowest = (spent: ReadonlyMap<string, number>): string =>
+    [...spent.entries()]
+      .sort((one, two) => two[1] - one[1])
+      .slice(0, 3)
+      .map(([rule, ms]) => rule + ' ' + seconds(ms))
+      .join(', ')
+  const own = new Map(run.spent)
+  for (const [rule, ms] of proving.spent) own.set(rule, (own.get(rule) ?? 0) + ms)
+  stdout.write(
+    'sweep: it took ' + seconds(done - began) + '. Loading the rules took ' + seconds(loaded - began) +
+      ', reading the files in this tree ' + seconds(walked - loaded) +
+      ', running each rule on its own examples ' + seconds(proved - walked) +
+      ', and holding what each rule recommends against every other rule ' + seconds(done - proved) +
+      '. Slowest on their own files and examples: ' + slowest(own) +
+      '. Slowest to hold against the rest: ' + slowest(crossing) + '.\n',
+  )
   const forbidding = findings.length - run.findings.filter((one) => named.get(one.rule)?.severity === 'warning').length
   if (forbidding > 0) exit(1)
   if (warned.size > 0) {

package/dist/knowledge/attach.js

@@ -1,7 +1,8 @@
-import { quoted } from "../core/rows.js";
+import { SHAPED } from '../core/init.js';
+import { quoted } from '../core/rows.js';
 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 '../core/thread.ts'
+const CONCEPTS_SOURCE = `import type { Member } from '${SHAPED}'
 
 export interface Concept extends Member {
   readonly avoid?: readonly string[]
@@ -288,7 +289,7 @@ export const ATTACH = {
         {
             file: 'knowledge.ts',
             source: [
-                "import type { Threaded } from '../core/thread.ts'",
+                `import type { Threaded } from '${SHAPED}'`,
                 '',
                 'export const KNOWLEDGE: Threaded = {',
                 "  id: 'knowledge',",

package/dist/knowledge/attach.ts

@@ -1,5 +1,6 @@
 import type { Attaching } from '../core/attach.ts'
 
+import { SHAPED } from '../core/init.ts'
 import { quoted } from '../core/rows.ts'
 
 const DESCRIBES =
@@ -8,7 +9,7 @@ const DESCRIBES =
 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 '../core/thread.ts'
+const CONCEPTS_SOURCE = `import type { Member } from '${SHAPED}'
 
 export interface Concept extends Member {
   readonly avoid?: readonly string[]
@@ -298,7 +299,7 @@ export const ATTACH: Attaching = {
     {
       file: 'knowledge.ts',
       source: [
-        "import type { Threaded } from '../core/thread.ts'",
+        `import type { Threaded } from '${SHAPED}'`,
         '',
         'export const KNOWLEDGE: Threaded = {',
         "  id: 'knowledge',",

package/dist/knowledge/generators/docsgen.js

@@ -1,10 +1,10 @@
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
 import { resolve } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
-import { exit } from "../../core/invoked.js";
-import { ROOT, descend } from "../../core/descend.js";
-import { forbids, runChecker } from "../../core/finding.js";
-import { agentInstructions } from "../../integrity/lint.js";
+import { exit } from '../../core/invoked.js';
+import { ROOT, descend } from '../../core/descend.js';
+import { forbids, runChecker } from '../../core/finding.js';
+import { agentInstructions } from '../../integrity/lint.js';
 const AT = 'docs.md';
 const CHECKING = argv.includes('--check');
 const SHOWING = argv.includes('--show');
@@ -71,7 +71,9 @@ const line = (one) => {
     ].join('\n');
 };
 const words = [...pass.coined].sort(([one], [two]) => (one < two ? -1 : 1));
-const commands = [...pass.derived.values(), ...[...under.values()].flat().map((one) => one.row)]
+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), one), new Map());
 const sections = [...under.keys()].sort();

package/dist/knowledge/generators/docsgen.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { dirname, resolve } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
 
@@ -96,7 +96,9 @@ const line = (one: { readonly list: string; readonly row: Row }): string => {
 
 const words = [...pass.coined].sort(([one], [two]) => (one < two ? -1 : 1))
 
-const commands = [...pass.derived.values(), ...[...under.values()].flat().map((one) => one.row)]
+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>())
 

package/dist/knowledge/generators/glossary.js

@@ -1,10 +1,10 @@
-import { existsSync, readFileSync, writeFileSync } from "../../core/files.js";
+import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.js';
 import { dirname, relative, resolve } from 'node:path';
 import { argv, stderr, stdout } from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { exit } from "../../core/invoked.js";
-import { ROOT, descend } from "../../core/descend.js";
-import { forbids, runChecker } from "../../core/finding.js";
+import { exit } from '../../core/invoked.js';
+import { ROOT, descend } from '../../core/descend.js';
+import { forbids, runChecker } from '../../core/finding.js';
 function refuse(why) {
     stderr.write(`glossary: ${why}\n`);
     exit(1);

package/dist/knowledge/generators/glossary.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from '../../core/files.ts'
+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'

package/dist/operations/access.d.ts

@@ -13,6 +13,29 @@ export declare function declaredWords(entities: readonly {
     };
 }[], which: 'roles' | 'entitlements', everybody: string): readonly string[];
 export declare function undeclared(answered: string, offers: readonly string[], which: 'roles' | 'entitlements'): string | undefined;
+export interface Declaring {
+    readonly id: string;
+    readonly holds: readonly {
+        readonly id: string;
+        readonly options?: readonly string[];
+    }[];
+    readonly rows?: readonly Record<string, unknown>[];
+    readonly must?: readonly {
+        readonly unique?: readonly string[];
+    }[];
+    readonly actor?: {
+        readonly roles: string;
+        readonly entitlements?: string;
+    };
+}
+export interface Caller {
+    readonly id: string;
+    readonly entity: string;
+    readonly roles: readonly string[];
+    readonly entitlements: readonly string[];
+}
+export declare const keyIn: (one: Declaring) => string | undefined;
+export declare const declaredCallers: (entities: readonly Declaring[]) => readonly Caller[];
 export interface Grant extends Member {
     readonly may: readonly string[];
     readonly on?: string;