@prestack/thread 0.1.2 → 0.1.4

package/dist/core/attach.ts

@@ -1,12 +1,14 @@
-import { existsSync, readFileSync, rmSync, writeFileSync } from './files.ts'
+import { installing, needing } from '../integrations/cli.ts'
+import { attached, existsSync, readFileSync, rmSync, writeFileSync } from '../integrations/disk.ts'
 import { createRequire } from 'node:module'
 import { join, relative, resolve } from 'node:path'
 import { stdout } from 'node:process'
 
 import { LISTS } from './descend.ts'
 import { ROOT, TREE, root as rooted } from './init.ts'
+import { BESIDE } from './invoked.ts'
 import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.ts'
-import { ours as isOurs } from './scope.ts'
+import { idOf, ours as isOurs } from './scope.ts'
 
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/
 
@@ -35,16 +37,6 @@ export interface Attaching {
   readonly declares: string
   readonly rows?: readonly Appending[]
 
-  readonly retires?: readonly {
-    readonly into: string
-    readonly list: string
-    readonly id: string
-
-    readonly made?: string
-
-    readonly why: string
-  }[]
-
   readonly attaches?: readonly string[]
 
   readonly scripts?: Readonly<Record<string, string>>
@@ -108,18 +100,27 @@ export async function attaches(into: string, name: string): Promise<boolean> {
   }
 }
 
+function shipped(spec: string, owner: string): string {
+  const rest = spec.slice(owner.length + 1)
+  const named = idOf(owner) ?? owner
+  const part = rest === DOOR.slice(1) ? named : String(rest.split('/')[0])
+  return new URL('../' + part + '/' + BESIDE('attach'), import.meta.url).href
+}
+
 async function attaching(into: string, name: string): Promise<Attaching> {
   const spec = name.endsWith(DOOR) ? name : `${name}${DOOR}`
   const owner = packageOf(name)
   let held: { ATTACH?: Attaching }
   try {
+    if (attached() && isOurs(owner)) held = (await import(shipped(spec, owner))) as { ATTACH?: Attaching }
+    else
     held = (await import(createRequire(join(into, 'package.json')).resolve(spec))) as { ATTACH?: Attaching }
   } catch {
     if (!existsSync(join(into, 'node_modules', owner, 'package.json'))) {
       throw new UnattachableError(
         owner,
-        `is not installed in this app — run \`npm i -D ${owner}\` first, because \`thread attach\` takes on a ` +
-          'package that is already here rather than fetching one',
+        'is not installed here, and fetching it did not put it on disk either. Check the name — `thread attach` ' +
+          'takes the package as the registry spells it. Nothing here was changed',
       )
     }
     throw new UnattachableError(
@@ -163,6 +164,28 @@ function edit(at: string, change: (text: string) => string, touched: Set<string>
   touched.add(relative(into, at))
 }
 
+function acquire(into: string, owner: string): void {
+  const manifest = join(into, 'package.json')
+  const was = readFileSync(manifest, 'utf8')
+  const parsed = JSON.parse(was) as Record<string, unknown> & { dependencies?: Record<string, string> }
+  stdout.write(`thread: ${owner} is not here yet, so this is fetching it. Nothing has to be typed for that.\n`)
+  writeFileSync(manifest, `${JSON.stringify({ ...parsed, dependencies: { ...parsed.dependencies, [owner]: 'latest' } }, null, 2)}\n`, 'utf8')
+  try {
+    installing(into)
+  } catch (thrown) {
+    writeFileSync(manifest, was, 'utf8')
+    throw new Error(
+      `${owner} could not be fetched — ${thrown instanceof Error ? thrown.message : String(thrown)} package.json is as it was, so nothing here names a package that is not on disk.`,
+    )
+  }
+  const at = join(into, 'node_modules', owner, 'package.json')
+  if (!existsSync(at)) return
+  const got = (JSON.parse(readFileSync(at, 'utf8')) as { version?: string }).version
+  if (got === undefined) return
+  const now = JSON.parse(readFileSync(manifest, 'utf8')) as Record<string, unknown> & { dependencies?: Record<string, string> }
+  writeFileSync(manifest, `${JSON.stringify({ ...now, dependencies: { ...now.dependencies, [owner]: '^' + got } }, null, 2)}\n`, 'utf8')
+}
+
 export async function attach(
   into: string,
   name: string,
@@ -174,13 +197,17 @@ export async function attach(
   const root = join(dir, ROOT)
   if (!existsSync(root)) throw new UnthreadedError()
 
+  const owned = packageOf(name)
+  if (!existsSync(join(into, 'node_modules', owned, 'package.json'))) acquire(into, owned)
+
   const one = await attaching(into, name)
 
   for (const on of one.attaches ?? []) {
+    if (!(await attaches(into, on))) acquire(into, packageOf(on))
     if (!(await attaches(into, on))) {
       throw new UnattachableError(
         name,
-        `must have ${on} attached before it, and ${on} is not installed here — run \`npm install -D ${packageOf(on)}\` and attach ${name} again. ` +
+        `must have ${on} attached before it, and fetching ${packageOf(on)} did not put it on disk. ` +
           `${on} is named in \`attaches\` and not in dependencies, because a package that only appends a row to a file ` +
           'another package owns would otherwise carry an npm edge it never imports',
       )
@@ -190,7 +217,6 @@ export async function attach(
 
   const plan = new Map<string, string>()
 
-  const retired: string[] = []
 
   const reshaped: string[] = []
 
@@ -336,13 +362,6 @@ export async function attach(
         if (where === undefined) return false
         return !text.slice(where.open, where.close).includes(each.source.trim().replace(/,$/, ''))
       }).length
-      const withdrawing = (one.retires ?? []).filter((gone) => {
-        const at = join(dir, gone.into)
-        if (!existsSync(at)) return false
-        const text = plan.get(at) ?? readFileSync(at, 'utf8')
-        const where = listBounds(text, gone.list)
-        return where !== undefined && holdsRow(text, where, gone.id)
-      }).length
 
       throw new Error(
         `${name} brings a noun called \`${coined}\`, and this tree already declares something by that name. One ` +
@@ -354,11 +373,10 @@ export async function attach(
 
           `A refusal here names a command you can actually run. If the one above does not fit what you are trying ` +
           `to do, that is a gap in this framework rather than something to work around — say so.` +
-          (waiting + withdrawing === 0
+          (waiting === 0
             ? ''
             : `\n\nAn attach is all or nothing, so this is also holding back everything else ${name} would have ` +
-              `delivered: ${String(waiting)} row(s) this tree does not hold at the version installed` +
-              `${withdrawing === 0 ? '' : ` and ${String(withdrawing)} it has withdrawn`}. None of that arrives until the ` +
+              `delivered: ${String(waiting)} row(s) this tree does not hold at the version installed. None of that arrives until the ` +
               `collision above is cleared, and nothing else will tell you — \`npm install\` will go on reporting this ` +
               `tree current.`),
       )
@@ -383,34 +401,6 @@ export async function attach(
     plan.set(target, withRow(held, bounds, row.source))
   }
 
-  for (const gone of one.retires ?? []) {
-    const shipped = (one.rows ?? []).find(
-      (row) => row.into === gone.into && row.list === gone.list && row.id === gone.id,
-    )
-    if (shipped !== undefined) {
-      throw new UnattachableError(
-        name,
-        `both ships and retires \`${gone.id}\` in ${gone.into}, so attaching it would add and remove one row`,
-      )
-    }
-
-    if (gone.made !== undefined) {
-      const byproduct = join(into, gone.made)
-      if (existsSync(byproduct)) {
-        rmSync(byproduct)
-        retired.push(`${gone.made} — the file \`${gone.id}\` derived, which nothing writes now`)
-      }
-    }
-
-    const target = join(dir, gone.into)
-    if (!existsSync(target) && !plan.has(target)) continue
-    const text = plan.get(target) ?? readFileSync(target, 'utf8')
-    const where = listBounds(text, gone.list)
-    if (where === undefined || !holdsRow(text, where, gone.id)) continue
-    plan.set(target, withoutRow(text, where, gone.id))
-    retired.push(`${gone.into}: ${gone.id} — ${gone.why}`)
-  }
-
   if (one.scripts !== undefined) {
     const manifest = join(into, 'package.json')
     const held = readFileSync(manifest, 'utf8')
@@ -427,19 +417,23 @@ export async function attach(
 
   if (one.needs !== undefined) {
     const manifest = join(into, 'package.json')
-
-    const held = plan.get(manifest) ?? readFileSync(manifest, 'utf8')
-    const parsed = JSON.parse(held) as Record<string, unknown> & { dependencies?: Record<string, string> }
-    const needs = { ...parsed.dependencies }
-    const added: string[] = []
-    for (const [name, at] of Object.entries(one.needs)) {
-      if (needs[name] !== undefined) continue
-      needs[name] = at
-      added.push(name)
+    const was = readFileSync(manifest, 'utf8')
+    const scripted = plan.get(manifest)
+    if (scripted !== undefined) {
+      writeFileSync(manifest, scripted, 'utf8')
+      plan.delete(manifest)
+      touched.add(relative(into, manifest))
+    }
+    let added: readonly string[]
+    try {
+      added = needing(into, one.needs)
+    } catch (thrown) {
+      writeFileSync(manifest, was, 'utf8')
+      throw new Error(`${thrown instanceof Error ? thrown.message : String(thrown)} Nothing was attached.`)
     }
     if (added.length > 0) {
-      plan.set(manifest, `${JSON.stringify({ ...parsed, dependencies: needs }, null, 2)}\n`)
-      stdout.write(`thread: added ${added.join(', ')} to dependencies — run \`npm install\` to fetch ${added.length === 1 ? 'it' : 'them'}\n`)
+      touched.add(relative(into, manifest))
+      stdout.write(`thread: ${name} needs ${added.join(', ')}, so ${added.length === 1 ? 'it is' : 'they are'} in package.json now and fetched. Nothing has to be typed for that.\n`)
     }
   }
 
@@ -459,7 +453,6 @@ export async function attach(
     touched.add(relative(into, path))
   }
 
-  for (const line of retired) stdout.write(`thread: retired ${line}\n`)
   for (const file of reshaped) stdout.write(`thread: reshaped ${file} — what a row may state has changed\n`)
   for (const id of noticed) stdout.write(`thread: declared ${id} — a file this app grew after \`thread init\` ran\n`)
 
@@ -545,7 +538,7 @@ export async function detach(into: string, name: string): Promise<readonly strin
 }
 
 const DESCRIBES =
-  'The package every tree installs first: the descent, the CLI, and the makers and generators that used to be separate packages.'
+  'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.'
 
 const CORE_SOURCE = `import type { Threaded } from '../core/thread.ts'
 
@@ -567,7 +560,7 @@ const SEEDED = {
     '    {',
     '      id: \'core\',',
     '      at: \'_threads/core.ts\',',
-    '      describes: \'The package every tree installs first: the descent, the CLI, and the makers and generators that used to be separate packages.\',',
+    '      describes: \'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.\',',
     '      version: 1,',
     '    },',
   ].join('\n'),

package/dist/core/chain.js

@@ -1,10 +1,10 @@
-import { spawnSync } from 'node:child_process';
+import { starts } from '../integrations/cli.js';
 import { join } from 'node:path';
 import { execPath } from 'node:process';
 import { fileURLToPath } from 'node:url';
-import { existsSync, readFileSync, readdirSync } from "./files.js";
-import { valuesIn } from "./rows.js";
-import { findTree } from "./tree.js";
+import { existsSync, readFileSync, readdirSync } from '../integrations/disk.js';
+import { valuesIn } from './rows.js';
+import { findTree } from './tree.js';
 const STATING = 'derivation.ts';
 export async function generators(tree = findTree()) {
     if (!existsSync(tree.dir))
@@ -39,12 +39,8 @@ export const REFUSED_BY = 'round: refused';
 export function batched(at, commands, within) {
     if (commands.length === 0)
         return [];
-    const out = spawnSync(execPath, [...LOADER, RUNNER, ...new Set(commands)], {
-        cwd: at,
-        encoding: 'utf8',
-        ...(within === undefined ? {} : { timeout: within, killSignal: 'SIGKILL' }),
-    });
-    const lines = `${out.stdout ?? ''}${out.stderr ?? ''}`.split('\n');
+    const out = starts(execPath, [...LOADER, RUNNER, ...new Set(commands)], { at, shows: 'errors', within });
+    const lines = out.out.split('\n');
     const found = new Map();
     let held = [];
     for (const line of lines) {
@@ -58,12 +54,12 @@ export function batched(at, commands, within) {
         held = [];
     }
     const orphaned = held.join('\n').trim();
-    const died = out.error !== undefined
-        ? ` The runner itself failed to start or was stopped: ${out.error.message}.`
-        : out.signal !== null && out.signal !== undefined
-            ? ` The runner was killed by ${out.signal}, so everything after the command it was running is unreported rather than refused.`
-            : found.size === 0 && out.status !== 0
-                ? ` The runner exited ${String(out.status)} having reported nothing, so it died before the first command finished.`
+    const died = out.why !== ''
+        ? ` The runner itself failed to start or was stopped: ${out.why}.`
+        : out.killed !== null
+            ? ` The runner was killed by ${out.killed} after ${String(within ?? 0)} ms. The last "settle: running" line above names the command it was inside, and everything after that one is unreported rather than refused.`
+            : found.size === 0 && !out.ok
+                ? ` The runner exited ${String(out.code)} having reported nothing, so it died before the first command finished.`
                 : '';
     let firstUnreached = true;
     return commands.map((one) => {
@@ -93,7 +89,7 @@ export function settling(at, all, skip = []) {
     let before;
     while (round < ROUNDS) {
         round += 1;
-        const asking = round === 1 ? mine.map((one) => word(one.runs)) : batch(at, mine.map((one) => word(one.runs))).refused;
+        const asking = batch(at, mine.map((one) => word(one.runs))).refused;
         const unhappy = mine.filter((one) => asking.includes(word(one.runs)));
         if (unhappy.length === 0)
             return { ran, unsettled: [], rounds: round };

package/dist/core/chain.ts

@@ -1,10 +1,10 @@
-import { spawnSync } from 'node:child_process'
+import { starts } from '../integrations/cli.ts'
 import { join } from 'node:path'
 import { execPath } from 'node:process'
 import { fileURLToPath } from 'node:url'
 
 import type { Row } from './descend.ts'
-import { existsSync, readFileSync, readdirSync } from './files.ts'
+import { existsSync, readFileSync, readdirSync } from '../integrations/disk.ts'
 import { valuesIn } from './rows.ts'
 import { findTree, type Tree } from './tree.ts'
 
@@ -58,12 +58,8 @@ export function batched(
 ): readonly { readonly command: string; readonly ok: boolean; readonly said: string }[] {
   if (commands.length === 0) return []
 
-  const out = spawnSync(execPath, [...LOADER, RUNNER, ...new Set(commands)], {
-    cwd: at,
-    encoding: 'utf8',
-    ...(within === undefined ? {} : { timeout: within, killSignal: 'SIGKILL' as const }),
-  })
-  const lines = `${out.stdout ?? ''}${out.stderr ?? ''}`.split('\n')
+  const out = starts(execPath, [...LOADER, RUNNER, ...new Set(commands)], { at, shows: 'errors', within })
+  const lines = out.out.split('\n')
 
   const found = new Map<string, { readonly command: string; readonly ok: boolean; readonly said: string }>()
   let held: string[] = []
@@ -80,12 +76,12 @@ export function batched(
 
   const orphaned = held.join('\n').trim()
   const died =
-    out.error !== undefined
-      ? ` The runner itself failed to start or was stopped: ${out.error.message}.`
-      : out.signal !== null && out.signal !== undefined
-        ? ` The runner was killed by ${out.signal}, so everything after the command it was running is unreported rather than refused.`
-        : found.size === 0 && out.status !== 0
-          ? ` The runner exited ${String(out.status)} having reported nothing, so it died before the first command finished.`
+    out.why !== ''
+      ? ` The runner itself failed to start or was stopped: ${out.why}.`
+      : out.killed !== null
+        ? ` The runner was killed by ${out.killed} after ${String(within ?? 0)} ms. The last "settle: running" line above names the command it was inside, and everything after that one is unreported rather than refused.`
+        : found.size === 0 && !out.ok
+          ? ` The runner exited ${String(out.code)} having reported nothing, so it died before the first command finished.`
           : ''
   let firstUnreached = true
   return commands.map((one) => {
@@ -127,7 +123,7 @@ export function settling(
   while (round < ROUNDS) {
     round += 1
 
-    const asking = round === 1 ? mine.map((one) => word(one.runs)) : batch(at, mine.map((one) => word(one.runs))).refused
+    const asking = batch(at, mine.map((one) => word(one.runs))).refused
     const unhappy = mine.filter((one) => asking.includes(word(one.runs)))
     if (unhappy.length === 0) return { ran, unsettled: [], rounds: round }
 

package/dist/core/condition.d.ts

@@ -1,8 +1,8 @@
 import { type Actor } from './actor.ts';
-export declare const COMPARE_OPS: readonly ["eq", "neq", "lt", "lte", "gt", "gte", "in", "has"];
+export declare const COMPARE_OPS: readonly ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'has'];
 export type CompareOp = (typeof COMPARE_OPS)[number];
-export declare const AGGREGATIONS: readonly ["count", "sum", "min", "max", "avg"];
-export declare const ACTOR_FACTS: readonly ["id", "roles", "entitlements", ...("run" | "address" | "device" | "replay")[]];
+export declare const AGGREGATIONS: readonly ['count', 'sum', 'min', 'max', 'avg'];
+export declare const ACTOR_FACTS: readonly ["id", "roles", "entitlements", ...("address" | "device" | "moment" | "replay" | "run")[]];
 export declare const AGO: RegExp;
 export type Operand = {
     readonly value: string | number | boolean | null;
@@ -41,7 +41,7 @@ export declare function walkOperands(condition: Condition, take: (one: Operand)
 export declare function mentionsActor(condition: Condition): boolean;
 export declare function agoSeconds(ago: string): number | undefined;
 export declare function satisfies(condition: Condition, actor: Actor): boolean;
-export declare const CONDITION_ANSWERS: readonly ["is", "than", "field", "value", "actor", "ago", "of", "how", "over", "op", "when", "joins"];
+export declare const CONDITION_ANSWERS: readonly ['is', 'than', 'field', 'value', 'actor', 'ago', 'of', 'how', 'over', 'op', 'when', 'joins'];
 export declare function conditioned(ask: (key: string, question: string) => Promise<string>, say: (line: string) => void, subject: {
     readonly id: string;
     readonly fields: readonly string[];

package/dist/core/condition.js

@@ -1,4 +1,4 @@
-import { ENVIRONMENT } from "./actor.js";
+import { ENVIRONMENT } from './actor.js';
 export const COMPARE_OPS = ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'has'];
 export const AGGREGATIONS = ['count', 'sum', 'min', 'max', 'avg'];
 export const ACTOR_FACTS = ['id', 'roles', 'entitlements', ...ENVIRONMENT.map(([fact]) => fact)];
@@ -182,7 +182,7 @@ export async function conditioned(ask, say, subject, all) {
     const first = held[0];
     return held.length === 1 ? first : joiner === 'all' ? { all: held } : { any: held };
 }
-import { quoted } from "./rows.js";
+import { quoted } from './rows.js';
 export function said(one) {
     if (typeof one === 'string')
         return quoted(one);

package/dist/core/descend.d.ts

@@ -4,7 +4,7 @@ export declare const ROOT: string;
 export declare const TREE: string;
 export declare const THREAD_AT: string;
 export declare function unkept(at: string): boolean;
-export declare const LISTS: readonly ["declares", "derives", "seeds"];
+export declare const LISTS: readonly ['declares', 'derives', 'seeds'];
 export declare const ROW_LISTS: readonly ["declares", "derives", "seeds", "holds"];
 export interface Row {
     readonly at?: string;
@@ -59,6 +59,7 @@ export declare function shapeFields(named: string, inside?: string): readonly {
     readonly map: boolean;
     readonly worded: boolean;
     readonly guide: string;
+    readonly record: readonly string[];
 }[];
 export interface Field {
     readonly name: string;
@@ -68,9 +69,10 @@ export interface Field {
     readonly boolean: boolean;
     readonly worded: boolean;
     readonly guide: string;
+    readonly record: readonly string[];
 }
 export declare function listShape(at: string, list: string): string | undefined;
-export declare function listFields(at: string, list: string): readonly Field[];
+export declare function listFields(at: string, list: string, within?: number): readonly Field[];
 export declare function rowShape(at: string, list: string): string | undefined;
 interface Held {
     readonly name: string;

package/dist/core/descend.js

@@ -1,10 +1,10 @@
-import { spawnSync } from 'node:child_process';
-import { attached, existsSync, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "./files.js";
+import { starts } from '../integrations/cli.js';
+import { attached, beyond, existsSync, here as answering, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from '../integrations/disk.js';
 import { dirname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
-import { ignored } from "./init.js";
-import { NAMED, ORGANISATION } from "./scope.js";
-import { findTree } from "./tree.js";
+import { ignored } from './init.js';
+import { NAMED, ORGANISATION } from './scope.js';
+import { findTree } from './tree.js';
 const BUILT = new Set(ignored()
     .split('\n')
     .map((one) => one.trim())
@@ -32,7 +32,7 @@ function ownIgnores() {
     if (readIgnores)
         return ignores;
     readIgnores = true;
-    if (!attached() && spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
+    if (!attached() && starts('git', ['rev-parse', '--is-inside-work-tree'], { at: ROOT }).ok) {
         return ignores;
     }
     try {
@@ -55,7 +55,7 @@ export function unkept(at) {
         return held;
     const own = ownIgnores();
     const found = own === undefined
-        ? spawnSync('git', ['check-ignore', '-q', '--', at], { cwd: ROOT, stdio: 'ignore' }).status === 0
+        ? starts('git', ['check-ignore', '-q', '--', at], { at: ROOT }).ok
         : own.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
     asked.set(at, found);
     return found;
@@ -198,7 +198,7 @@ function listing(at, take, skip, only, deep) {
 function parsing(from) {
     return {
         useCaseSensitiveFileNames: true,
-        fileExists: (at) => existsSync(at),
+        fileExists: (at) => !beyond(at) && existsSync(at),
         readFile: (at) => {
             try {
                 return readFileSync(at);
@@ -237,23 +237,34 @@ export function configured() {
     }
     return { options: { ...FALLBACK, ...INVARIANT }, from: '' };
 }
+const libraries = new Map();
+const DEPENDENCIES = '/node_' + 'modules/';
 export function hosting(options) {
     const host = ts.createCompilerHost(options, true);
     const lib = host.getDefaultLibLocation?.();
+    const settings = JSON.stringify(options);
     const toolchain = (at) => lib !== undefined && (at === lib || at.startsWith(`${lib}/`));
+    const seen = (at) => (beyond(at) ? 'none' : kind(at));
     return {
         ...host,
-        fileExists: (at) => (toolchain(at) ? host.fileExists(at) : kind(at) === 'file'),
-        directoryExists: (at) => (toolchain(at) ? (host.directoryExists?.(at) ?? false) : kind(at) === 'folder'),
-        readFile: (at) => (toolchain(at) ? host.readFile(at) : kind(at) === 'file' ? readFileSync(at) : undefined),
+        fileExists: (at) => (toolchain(at) ? host.fileExists(at) : seen(at) === 'file'),
+        directoryExists: (at) => (toolchain(at) ? (host.directoryExists?.(at) ?? false) : seen(at) === 'folder'),
+        readFile: (at) => (toolchain(at) ? host.readFile(at) : seen(at) === 'file' ? readFileSync(at) : undefined),
         getSourceFile: (at, version) => {
-            if (toolchain(at))
-                return host.getSourceFile(at, version);
-            if (kind(at) !== 'file')
-                return undefined;
-            return ts.createSourceFile(at, readFileSync(at), version, true);
+            const lasting = toolchain(at) ? true : at.includes(DEPENDENCIES);
+            const key = settings + at + JSON.stringify(version);
+            if (lasting && libraries.has(key))
+                return libraries.get(key);
+            const made = toolchain(at)
+                ? host.getSourceFile(at, version)
+                : seen(at) === 'file'
+                    ? ts.createSourceFile(at, readFileSync(at), version, true)
+                    : undefined;
+            if (lasting)
+                libraries.set(key, made);
+            return made;
         },
-        getDirectories: (at) => kind(at) === 'folder' ? readdirSync(at, { withFileTypes: true }).filter((one) => one.isDirectory()).map((one) => one.name) : [],
+        getDirectories: (at) => seen(at) === 'folder' ? readdirSync(at, { withFileTypes: true }).filter((one) => one.isDirectory()).map((one) => one.name) : [],
         realpath: (at) => (toolchain(at) ? (host.realpath?.(at) ?? at) : realpathSync(at)),
         writeFile: (at, said) => {
             writeFileSync(at, said);
@@ -328,8 +339,13 @@ export function read(at) {
     source.set(at, text);
     return text;
 }
+const shapes = new WeakMap();
 export function shapesNamed() {
-    const { program, checker } = compiled();
+    const held = compiled();
+    const known = shapes.get(held);
+    if (known !== undefined)
+        return known;
+    const { program, checker } = held;
     const shape = threadedType(checker, program);
     const found = new Map();
     if (shape === undefined)
@@ -368,6 +384,7 @@ export function shapesNamed() {
             found.set(named, [...where, at]);
         }
     }
+    shapes.set(held, found);
     return found;
 }
 export function threading() {
@@ -408,13 +425,14 @@ export function shapeFields(named, inside) {
                     map: mapped(kind),
                     worded: (kind.isUnion() ? kind.types : [kind]).some((each) => (each.flags & ts.TypeFlags.StringLike) !== 0),
                     guide: ts.displayPartsToString(one.getDocumentationComment(checker)).trim(),
+                    record: recordOf(checker, kind),
                 };
             });
         }
     }
     return [];
 }
-function elementAt(at, list) {
+function elementAt(at, list, within) {
     const { program, checker } = compiled();
     const file = program.getSourceFile(resolve(ROOT, at));
     if (file === undefined)
@@ -424,6 +442,8 @@ function elementAt(at, list) {
     const consider = (node) => {
         if (held !== undefined)
             return;
+        if (within !== undefined && node.getStart() !== within)
+            return;
         const wanted = checker.getContextualType(node) ?? checker.getTypeAtLocation(node);
         const kinds = (wanted.isUnionOrIntersection() ? wanted.types : [wanted])
             .filter((one) => checker.getIndexTypeOfType(one, ts.IndexKind.Number) !== undefined)
@@ -455,8 +475,8 @@ export function listShape(at, list) {
     const held = elementAt(at, list);
     return held === undefined ? undefined : compiled().checker.typeToString(held.type);
 }
-export function listFields(at, list) {
-    const held = elementAt(at, list);
+export function listFields(at, list, within) {
+    const held = elementAt(at, list, within);
     if (held === undefined)
         return [];
     const { checker } = compiled();
@@ -480,12 +500,29 @@ export function listFields(at, list) {
             boolean: flagged(kind),
             worded: worded(kind),
             guide: ts.displayPartsToString(one.getDocumentationComment(checker)).trim(),
+            record: recordOf(checker, kind),
         };
     });
 }
 function elementOf(checker, type) {
     return checker.getIndexTypeOfType(type, ts.IndexKind.Number) ?? type;
 }
+function recordOf(checker, type) {
+    for (const each of type.isUnion() ? type.types : [type]) {
+        if ((each.flags & ts.TypeFlags.StringLike) !== 0 || checker.getIndexTypeOfType(each, ts.IndexKind.Number) === undefined)
+            continue;
+        const element = elementOf(checker, each);
+        if ((element.flags & ts.TypeFlags.Object) === 0)
+            return [];
+        const fields = checker.getPropertiesOfType(element);
+        const worded = fields.every((one) => {
+            const kind = checker.getNonNullableType(checker.getTypeOfSymbol(one));
+            return (kind.isUnion() ? kind.types : [kind]).every((part) => (part.flags & ts.TypeFlags.StringLike) !== 0);
+        });
+        return worded ? fields.map((one) => one.getName()) : [];
+    }
+    return [];
+}
 export function rowShape(at, list) {
     const { program, checker } = compiled();
     const file = program.getSourceFile(resolve(ROOT, at));
@@ -666,7 +703,38 @@ let passed;
 export function reached() {
     return [THREAD_AT, ...descend().threaded.keys()];
 }
+let world = answering();
+const worlds = new WeakMap();
+function kept() {
+    const was = { passed, built, scanned, commands, ignores, readIgnores, source: new Map(source), asked: new Map(asked) };
+    return () => {
+        passed = was.passed;
+        built = was.built;
+        scanned = was.scanned;
+        commands = was.commands;
+        ignores = was.ignores;
+        readIgnores = was.readIgnores;
+        source.clear();
+        for (const [at, text] of was.source)
+            source.set(at, text);
+        asked.clear();
+        for (const [at, ignore] of was.asked)
+            asked.set(at, ignore);
+    };
+}
 export function forget() {
+    const now = answering();
+    if (now === world)
+        libraries.clear();
+    else {
+        worlds.set(world, kept());
+        world = now;
+        const back = worlds.get(now);
+        if (back !== undefined) {
+            back();
+            return;
+        }
+    }
     passed = undefined;
     built = undefined;
     scanned = undefined;