@prestack/thread 0.0.2 → 0.1.0

package/dist/core/client.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { argv, cwd, env, stderr, stdout } from 'node:process';
+import { kind, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "./files.js";
+import { exit, invoked } from "./invoked.js";
+import { THING } from "./scope.js";
+const HERE = cwd();
+const REASONS = {
+    ENOENT: 'is not there',
+    EACCES: 'is there, and this machine does not allow it',
+    EPERM: 'is there, and this machine does not allow it',
+    EISDIR: 'is a folder, and that order is for a file',
+    ENOTDIR: 'has a file part-way along its path where a folder was expected',
+    ENOTEMPTY: 'still holds something',
+};
+const HOME = (() => {
+    try {
+        return realpathSync(HERE);
+    }
+    catch {
+        return HERE;
+    }
+})();
+function deepest(at) {
+    let found = at;
+    while (kind(found) === 'none') {
+        const up = dirname(found);
+        if (up === found)
+            return found;
+        found = up;
+    }
+    return found;
+}
+function inside(at) {
+    let real;
+    try {
+        real = realpathSync(deepest(resolve(HERE, at)));
+    }
+    catch {
+        return false;
+    }
+    const step = relative(HOME, real);
+    return step === '' || (!step.startsWith('..') && !isAbsolute(step));
+}
+function rootly(at) {
+    const asked = resolve(HERE, at);
+    if (kind(asked) === 'none')
+        return false;
+    try {
+        return realpathSync(asked) === HOME;
+    }
+    catch {
+        return false;
+    }
+}
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+function local(at) {
+    try {
+        return LOOPBACK.has(new URL(at).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function why(at, thrown) {
+    const held = thrown instanceof Error ? Reflect.get(thrown, 'code') : undefined;
+    const said = typeof held === 'string' ? REASONS[held] : undefined;
+    if (said !== undefined)
+        return `${at} ${said}.`;
+    return `${at} could not be reached — ${thrown instanceof Error ? thrown.message : String(thrown)}.`;
+}
+export function carry(one) {
+    if (!inside(one.at)) {
+        return {
+            answered: 'refused',
+            because: `${one.at} is outside ${HERE} once its links are followed, and this answers only for what is really inside the repository it was run in.`,
+        };
+    }
+    if (one.order === 'remove' && rootly(one.at)) {
+        return {
+            answered: 'refused',
+            because: `${one.at} is the repository this was run in, and this carries orders inside it rather than taking it away.`,
+        };
+    }
+    try {
+        if (one.order === 'kind')
+            return { answered: 'kind', held: kind(one.at) };
+        if (one.order === 'read')
+            return { answered: 'read', said: readFileSync(one.at) };
+        if (one.order === 'list') {
+            const held = readdirSync(one.at, { withFileTypes: true }).map((each) => ({
+                name: each.name,
+                kind: each.isFile() ? 'file' : each.isDirectory() ? 'folder' : 'other',
+            }));
+            return { answered: 'list', held };
+        }
+        if (one.order === 'stat') {
+            const held = statSync(one.at);
+            return { answered: 'stat', held: { size: held.size, modified: held.mtimeMs } };
+        }
+        if (one.order === 'remove') {
+            rmSync(one.at, { recursive: true, force: true });
+            return { answered: 'removed' };
+        }
+        if (one.order === 'real')
+            return { answered: 'real', at: realpathSync(one.at) };
+        writeFileSync(one.at, one.said);
+        return { answered: 'written' };
+    }
+    catch (thrown) {
+        return { answered: 'refused', because: why(one.at, thrown) };
+    }
+}
+const AT = 'THREAD_SERVER';
+const KEY = 'THREAD_KEY';
+const ROUNDS = 100;
+async function sending(at, key, body) {
+    const said = await fetch(at, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
+        body: JSON.stringify(body),
+    });
+    if (said.status === 401 || said.status === 403)
+        throw new Error(`the key in ${KEY} is not one ${at} accepts`);
+    if (!said.ok)
+        throw new Error(`${at} answered ${String(said.status)}`);
+    return (await said.json());
+}
+export async function talking(at, key, message) {
+    let turn = await sending(at, key, { said: message });
+    for (let spun = 0; spun < ROUNDS; spun += 1) {
+        if (turn.say !== undefined && turn.say !== '')
+            stdout.write(`${turn.say}\n`);
+        if (turn.done === true)
+            return 0;
+        turn = await sending(at, key, { of: turn.of, answered: (turn.orders ?? []).map(carry) });
+    }
+    stderr.write(`${THING}: this went ${String(ROUNDS)} rounds without finishing, so it was stopped there. What is already\n` +
+        `in this repository stands, and nothing half-written was left behind — every change is one order, carried\n` +
+        `and answered before the next one is asked for.\n`);
+    return 1;
+}
+export async function run(said) {
+    if (said.length === 0) {
+        stdout.write(`${THING}: say what you want built, in one sentence, in quotes.\n\n  ${THING} "take payments with stripe"\n\n` +
+            `That sentence is the whole of what this takes — there is no command here to look up. Nothing on this\n` +
+            `machine declares a row, writes a file or runs a check. What comes back is written into this repository\n` +
+            `for you, and every check this framework runs has to pass before it stays.\n`);
+        return 0;
+    }
+    const message = said.length === 1 ? (said[0] ?? '') : '';
+    if (!message.includes(' ')) {
+        stderr.write(`${THING}: there is no \`${said.join(' ')}\` here, and no other command to find instead. This takes one\n` +
+            `sentence, in quotes, and nothing else — ${THING} "take payments with stripe". Say what you want and it\n` +
+            `is answered where the work happens, never on this machine.\n`);
+        return 1;
+    }
+    const at = env[AT];
+    if (at === undefined || at === '') {
+        stderr.write(`${THING}: there is nowhere to send that yet. This copy has no server to answer it — ${AT} names one, and\n` +
+            `nothing here is set to one.\n`);
+        return 1;
+    }
+    if (!local(at)) {
+        stderr.write(`${THING}: ${AT} names ${at}, which is not on this machine, and this only ever talks to a server running\n` +
+            `here. Set ${AT} to a http://localhost address and say it again. Nothing was sent.\n`);
+        return 1;
+    }
+    const key = env[KEY];
+    if (key === undefined || key === '') {
+        stderr.write(`${THING}: nothing here says who is asking, and ${at} answers no one it cannot name. ${KEY} carries your\n` +
+            `key, and nothing on this machine is set to one. Set it in this terminal and say it again — it is read\n` +
+            `from there, never written into this repository and never sent anywhere but ${at}.\n`);
+        return 1;
+    }
+    try {
+        return await talking(at, key, message);
+    }
+    catch (thrown) {
+        stderr.write(`${THING}: ${at} could not answer — ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was\n` +
+            `written, so this repository is as it was.\n`);
+        return 1;
+    }
+}
+if (invoked(import.meta.url))
+    exit(await run(argv.slice(2)));

package/dist/core/client.ts

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import { dirname, isAbsolute, relative, resolve } from 'node:path'
+import { argv, cwd, env, stderr, stdout } from 'node:process'
+import { kind, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, type Kind, type Listed, type Measured } from './files.ts'
+import { exit, invoked } from './invoked.ts'
+import { THING } from './scope.ts'
+
+export type Order =
+  | { readonly order: 'kind'; readonly at: string }
+  | { readonly order: 'read'; readonly at: string }
+  | { readonly order: 'list'; readonly at: string }
+  | { readonly order: 'stat'; readonly at: string }
+  | { readonly order: 'remove'; readonly at: string }
+  | { readonly order: 'real'; readonly at: string }
+  | { readonly order: 'write'; readonly at: string; readonly said: string }
+
+export type Answered =
+  | { readonly answered: 'kind'; readonly held: Kind }
+  | { readonly answered: 'read'; readonly said: string }
+  | { readonly answered: 'list'; readonly held: readonly Listed[] }
+  | { readonly answered: 'stat'; readonly held: Measured }
+  | { readonly answered: 'written' }
+  | { readonly answered: 'removed' }
+  | { readonly answered: 'real'; readonly at: string }
+  | { readonly answered: 'refused'; readonly because: string }
+
+const HERE = cwd()
+
+const REASONS: Readonly<Record<string, string>> = {
+  ENOENT: 'is not there',
+  EACCES: 'is there, and this machine does not allow it',
+  EPERM: 'is there, and this machine does not allow it',
+  EISDIR: 'is a folder, and that order is for a file',
+  ENOTDIR: 'has a file part-way along its path where a folder was expected',
+  ENOTEMPTY: 'still holds something',
+}
+
+const HOME = ((): string => {
+  try {
+    return realpathSync(HERE)
+  } catch {
+    return HERE
+  }
+})()
+
+function deepest(at: string): string {
+  let found = at
+  while (kind(found) === 'none') {
+    const up = dirname(found)
+    if (up === found) return found
+    found = up
+  }
+  return found
+}
+
+function inside(at: string): boolean {
+  let real: string
+  try {
+    real = realpathSync(deepest(resolve(HERE, at)))
+  } catch {
+    return false
+  }
+  const step = relative(HOME, real)
+  return step === '' || (!step.startsWith('..') && !isAbsolute(step))
+}
+
+function rootly(at: string): boolean {
+  const asked = resolve(HERE, at)
+  if (kind(asked) === 'none') return false
+  try {
+    return realpathSync(asked) === HOME
+  } catch {
+    return false
+  }
+}
+
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]', '::1'])
+
+function local(at: string): boolean {
+  try {
+    return LOOPBACK.has(new URL(at).hostname)
+  } catch {
+    return false
+  }
+}
+
+function why(at: string, thrown: unknown): string {
+  const held: unknown = thrown instanceof Error ? Reflect.get(thrown, 'code') : undefined
+  const said = typeof held === 'string' ? REASONS[held] : undefined
+  if (said !== undefined) return `${at} ${said}.`
+  return `${at} could not be reached — ${thrown instanceof Error ? thrown.message : String(thrown)}.`
+}
+
+export function carry(one: Order): Answered {
+  if (!inside(one.at)) {
+    return {
+      answered: 'refused',
+      because: `${one.at} is outside ${HERE} once its links are followed, and this answers only for what is really inside the repository it was run in.`,
+    }
+  }
+  if (one.order === 'remove' && rootly(one.at)) {
+    return {
+      answered: 'refused',
+      because: `${one.at} is the repository this was run in, and this carries orders inside it rather than taking it away.`,
+    }
+  }
+  try {
+    if (one.order === 'kind') return { answered: 'kind', held: kind(one.at) }
+    if (one.order === 'read') return { answered: 'read', said: readFileSync(one.at) }
+    if (one.order === 'list') {
+      const held = readdirSync(one.at, { withFileTypes: true }).map((each) => ({
+        name: each.name,
+        kind: each.isFile() ? ('file' as const) : each.isDirectory() ? ('folder' as const) : ('other' as const),
+      }))
+      return { answered: 'list', held }
+    }
+    if (one.order === 'stat') {
+      const held = statSync(one.at)
+      return { answered: 'stat', held: { size: held.size, modified: held.mtimeMs } }
+    }
+    if (one.order === 'remove') {
+      rmSync(one.at, { recursive: true, force: true })
+      return { answered: 'removed' }
+    }
+    if (one.order === 'real') return { answered: 'real', at: realpathSync(one.at) }
+    writeFileSync(one.at, one.said)
+    return { answered: 'written' }
+  } catch (thrown) {
+    return { answered: 'refused', because: why(one.at, thrown) }
+  }
+}
+
+export interface Turn {
+  readonly of: string
+  readonly orders?: readonly Order[]
+  readonly say?: string
+  readonly done?: boolean
+}
+
+const AT = 'THREAD_SERVER'
+
+const KEY = 'THREAD_KEY'
+
+const ROUNDS = 100
+
+async function sending(at: string, key: string, body: unknown): Promise<Turn> {
+  const said = await fetch(at, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
+    body: JSON.stringify(body),
+  })
+  if (said.status === 401 || said.status === 403) throw new Error(`the key in ${KEY} is not one ${at} accepts`)
+  if (!said.ok) throw new Error(`${at} answered ${String(said.status)}`)
+  return (await said.json()) as Turn
+}
+
+export async function talking(at: string, key: string, message: string): Promise<number> {
+  let turn = await sending(at, key, { said: message })
+  for (let spun = 0; spun < ROUNDS; spun += 1) {
+    if (turn.say !== undefined && turn.say !== '') stdout.write(`${turn.say}\n`)
+    if (turn.done === true) return 0
+    turn = await sending(at, key, { of: turn.of, answered: (turn.orders ?? []).map(carry) })
+  }
+  stderr.write(
+    `${THING}: this went ${String(ROUNDS)} rounds without finishing, so it was stopped there. What is already\n` +
+      `in this repository stands, and nothing half-written was left behind — every change is one order, carried\n` +
+      `and answered before the next one is asked for.\n`,
+  )
+  return 1
+}
+
+export async function run(said: readonly string[]): Promise<number> {
+  if (said.length === 0) {
+    stdout.write(
+      `${THING}: say what you want built, in one sentence, in quotes.\n\n  ${THING} "take payments with stripe"\n\n` +
+        `That sentence is the whole of what this takes — there is no command here to look up. Nothing on this\n` +
+        `machine declares a row, writes a file or runs a check. What comes back is written into this repository\n` +
+        `for you, and every check this framework runs has to pass before it stays.\n`,
+    )
+    return 0
+  }
+  const message = said.length === 1 ? (said[0] ?? '') : ''
+  if (!message.includes(' ')) {
+    stderr.write(
+      `${THING}: there is no \`${said.join(' ')}\` here, and no other command to find instead. This takes one\n` +
+        `sentence, in quotes, and nothing else — ${THING} "take payments with stripe". Say what you want and it\n` +
+        `is answered where the work happens, never on this machine.\n`,
+    )
+    return 1
+  }
+  const at = env[AT]
+  if (at === undefined || at === '') {
+    stderr.write(
+      `${THING}: there is nowhere to send that yet. This copy has no server to answer it — ${AT} names one, and\n` +
+        `nothing here is set to one.\n`,
+    )
+    return 1
+  }
+  if (!local(at)) {
+    stderr.write(
+      `${THING}: ${AT} names ${at}, which is not on this machine, and this only ever talks to a server running\n` +
+        `here. Set ${AT} to a http://localhost address and say it again. Nothing was sent.\n`,
+    )
+    return 1
+  }
+
+  const key = env[KEY]
+  if (key === undefined || key === '') {
+    stderr.write(
+      `${THING}: nothing here says who is asking, and ${at} answers no one it cannot name. ${KEY} carries your\n` +
+        `key, and nothing on this machine is set to one. Set it in this terminal and say it again — it is read\n` +
+        `from there, never written into this repository and never sent anywhere but ${at}.\n`,
+    )
+    return 1
+  }
+  try {
+    return await talking(at, key, message)
+  } catch (thrown) {
+    stderr.write(
+      `${THING}: ${at} could not answer — ${thrown instanceof Error ? thrown.message : String(thrown)}. Nothing was\n` +
+        `written, so this repository is as it was.\n`,
+    )
+    return 1
+  }
+}
+
+if (invoked(import.meta.url)) exit(await run(argv.slice(2)))

package/dist/core/descend.d.ts

@@ -5,6 +5,7 @@ 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 ROW_LISTS: readonly ["declares", "derives", "seeds", "holds"];
 export interface Row {
     readonly at?: string;
     readonly id?: string;
@@ -46,6 +47,7 @@ export declare function configured(): {
     readonly from: string;
     readonly trouble?: string;
 };
+export declare function hosting(options: ts.CompilerOptions): ts.CompilerHost;
 export declare function uncompiled(): readonly Finding[];
 export declare function read(at: string): string | undefined;
 export declare function shapesNamed(): ReadonlyMap<string, readonly string[]>;

package/dist/core/descend.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { attached, existsSync, kind, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "./files.js";
 import { dirname, join, relative, resolve } from 'node:path';
 import ts from 'typescript';
 import { ignored } from "./init.js";
@@ -26,12 +26,17 @@ function rooted() {
 export const ROOT = TREE_AT?.at ?? NOWHERE;
 export const TREE = `${TREE_AT?.name ?? NOWHERE}/`;
 export const THREAD_AT = `${TREE_AT?.name ?? NOWHERE}/thread.ts`;
-const OWN_IGNORES = (() => {
-    if (spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
-        return undefined;
+let ignores;
+let readIgnores = false;
+function ownIgnores() {
+    if (readIgnores)
+        return ignores;
+    readIgnores = true;
+    if (!attached() && spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
+        return ignores;
     }
     try {
-        return readFileSync(join(ROOT, '.gitignore'), 'utf8')
+        ignores = readFileSync(join(ROOT, '.gitignore'), 'utf8')
             .split('\n')
             .map((one) => one.trim())
             .filter((one) => one !== '' && !one.startsWith('#') && !one.startsWith('!'))
@@ -39,21 +44,24 @@ const OWN_IGNORES = (() => {
             .filter((one) => one !== '' && !one.includes('*'));
     }
     catch {
-        return [];
+        ignores = [];
     }
-})();
+    return ignores;
+}
 const asked = new Map();
 export function unkept(at) {
     const held = asked.get(at);
     if (held !== undefined)
         return held;
-    const found = OWN_IGNORES === undefined
+    const own = ownIgnores();
+    const found = own === undefined
         ? spawnSync('git', ['check-ignore', '-q', '--', at], { cwd: ROOT, stdio: 'ignore' }).status === 0
-        : OWN_IGNORES.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
+        : own.some((one) => at === one || at.startsWith(`${one}/`) || at.split('/').includes(one));
     asked.set(at, found);
     return found;
 }
 export const LISTS = ['declares', 'derives', 'seeds'];
+export const ROW_LISTS = [...LISTS, 'holds'];
 const SOURCE = /\.(ts|tsx|mts|cts)$/;
 const RUNNER = /^(?:pnpm|npm|yarn) (?:run )?([\w:.-]+)/;
 export function under(pass, id, root, seen = new Set()) {
@@ -148,12 +156,67 @@ const INVARIANT = {
     allowJs: true,
     jsx: ts.JsxEmit.ReactJSX,
 };
+const NEVER = ['node_modules', 'bower_components', 'jspm_packages'];
+function bounds(from, one) {
+    const star = one.indexOf('*');
+    if (star === -1)
+        return { under: resolve(from, one), ending: '' };
+    const head = one.slice(0, star);
+    const cut = head.lastIndexOf('/');
+    const tail = one.slice(star);
+    const dot = tail.lastIndexOf('.');
+    const end = dot === -1 ? '' : tail.slice(dot);
+    return {
+        under: resolve(from, cut === -1 ? '' : head.slice(0, cut)),
+        ending: end.includes('/') || end.includes('*') ? '' : end,
+    };
+}
+function wanted(at, only) {
+    if (only.length === 0)
+        return true;
+    return only.some((one) => (at === one.under || at.startsWith(`${one.under}/`)) && at.endsWith(one.ending));
+}
+function listing(at, take, skip, only, deep) {
+    const found = [];
+    if (deep < 0 || !existsSync(at))
+        return found;
+    for (const one of readdirSync(at, { withFileTypes: true })) {
+        const full = join(at, one.name);
+        if (skip.some((each) => full === each || full.startsWith(`${each}/`)))
+            continue;
+        if (one.isDirectory()) {
+            if (NEVER.includes(one.name))
+                continue;
+            found.push(...listing(full, take, skip, only, deep - 1));
+        }
+        else if (take.some((each) => one.name.endsWith(each)) && wanted(full, only)) {
+            found.push(full);
+        }
+    }
+    return found;
+}
+function parsing(from) {
+    return {
+        useCaseSensitiveFileNames: true,
+        fileExists: (at) => existsSync(at),
+        readFile: (at) => {
+            try {
+                return readFileSync(at);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        readDirectory: (at, take, skip, only, deep) => listing(at, take, (skip ?? []).map((one) => resolve(from, one.endsWith('/**') ? one.slice(0, -3) : one)), only.map((one) => bounds(from, one)), deep ?? Number.MAX_SAFE_INTEGER),
+    };
+}
 export function configured() {
     for (const name of CONFIGS) {
         const at = join(ROOT, name);
-        if (!ts.sys.fileExists(at))
+        if (!existsSync(at))
             continue;
-        const held = ts.readConfigFile(at, ts.sys.readFile.bind(ts.sys));
+        const host = parsing(ROOT);
+        const held = ts.readConfigFile(at, host.readFile);
         if (held.error !== undefined) {
             return {
                 options: { ...FALLBACK, ...INVARIANT },
@@ -161,7 +224,7 @@ export function configured() {
                 trouble: `${name} is there and cannot be read: ${ts.flattenDiagnosticMessageText(held.error.messageText, ' ')}`,
             };
         }
-        const parsed = ts.parseJsonConfigFileContent(held.config, ts.sys, dirname(at));
+        const parsed = ts.parseJsonConfigFileContent(held.config, host, dirname(at));
         const complained = parsed.errors[0];
         if (complained !== undefined) {
             return {
@@ -174,13 +237,37 @@ export function configured() {
     }
     return { options: { ...FALLBACK, ...INVARIANT }, from: '' };
 }
+export function hosting(options) {
+    const host = ts.createCompilerHost(options, true);
+    const lib = host.getDefaultLibLocation?.();
+    const toolchain = (at) => lib !== undefined && (at === lib || at.startsWith(`${lib}/`));
+    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),
+        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);
+        },
+        getDirectories: (at) => kind(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);
+        },
+    };
+}
 let built;
 function compiled() {
     rooted();
     if (built !== undefined)
         return built;
     const roots = [THREAD_AT, ...sources(), ...shipped()].filter((one) => SOURCE.test(one)).map((one) => resolve(ROOT, one));
-    const program = ts.createProgram([...new Set(roots)], configured().options);
+    const options = configured().options;
+    const program = ts.createProgram([...new Set(roots)], options, hosting(options));
     built = { program, checker: program.getTypeChecker() };
     return built;
 }
@@ -585,6 +672,9 @@ export function forget() {
     scanned = undefined;
     commands = undefined;
     source.clear();
+    asked.clear();
+    ignores = undefined;
+    readIgnores = false;
 }
 export function descend() {
     rooted();
@@ -762,7 +852,10 @@ export function descend() {
                 continue;
             }
             for (const one of value.elements) {
-                if (!ts.isObjectLiteralExpression(one)) {
+                const declaration = ts.isIdentifier(one) ? checker.getSymbolAtLocation(one)?.valueDeclaration : undefined;
+                const initial = declaration !== undefined && ts.isVariableDeclaration(declaration) ? unwrap(declaration.initializer) : undefined;
+                const object = ts.isObjectLiteralExpression(one) ? one : initial !== undefined && ts.isObjectLiteralExpression(initial) ? initial : undefined;
+                if (object === undefined) {
                     findings.push({
                         file: at,
                         detail: `\`${by}\` holds something in \`${list}\` that is not a row written out here`,
@@ -773,7 +866,7 @@ export function descend() {
                 rows += 1;
                 const wanted = checker.getContextualType(one);
                 const kind = wanted === undefined ? undefined : elementOf(checker, wanted);
-                const row = rowOf(one, kind === undefined ? type : checker.typeToString(kind), at, kind);
+                const row = rowOf(object, kind === undefined ? type : checker.typeToString(kind), at, kind);
                 coin(row.id, row.describes, under, by);
                 judge(row, by, list, false);
                 if (row.at !== undefined) {
@@ -782,7 +875,7 @@ export function descend() {
                         derived.set(row.id, row);
                 }
                 if (LISTS.some((name) => row.fields.has(name)))
-                    into(one, row.type, at, under, by, true);
+                    into(object, row.type, at, under, by, true);
                 if (row.at !== undefined)
                     open(row.at, wanted === undefined ? undefined : elementOf(checker, wanted), under, row.id ?? by, by);
             }