@prestack/thread 0.0.2 → 0.1.0

package/dist/core/descend.ts

@@ -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.ts'
 import { dirname, join, relative, resolve } from 'node:path'
 
 import ts from 'typescript'
@@ -35,37 +35,46 @@ 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: readonly string[] | undefined = (() => {
-  if (spawnSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: ROOT, stdio: 'ignore' }).status === 0) {
-    return undefined
+let ignores: readonly string[] | undefined
+let readIgnores = false
+
+function ownIgnores(): readonly string[] | undefined {
+  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('!'))
       .map((one) => one.replace(/^\/+|\/+$/g, ''))
       .filter((one) => one !== '' && !one.includes('*'))
   } catch {
-    return []
+    ignores = []
   }
-})()
+  return ignores
+}
 
 const asked = new Map<string, boolean>()
 
 export function unkept(at: string): boolean {
   const held = asked.get(at)
   if (held !== undefined) return held
+  const own = ownIgnores()
   const found =
-    OWN_IGNORES === undefined
+    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'] as const
 
+export const ROW_LISTS = [...LISTS, 'holds'] as const
+
 const SOURCE = /\.(ts|tsx|mts|cts)$/
 const RUNNER = /^(?:pnpm|npm|yarn) (?:run )?([\w:.-]+)/
 
@@ -198,12 +207,77 @@ const INVARIANT: ts.CompilerOptions = {
   jsx: ts.JsxEmit.ReactJSX,
 }
 
+const NEVER: readonly string[] = ['node_modules', 'bower_components', 'jspm_packages']
+
+interface Wanted {
+  readonly under: string
+  readonly ending: string
+}
+
+function bounds(from: string, one: string): Wanted {
+  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: string, only: readonly Wanted[]): boolean {
+  if (only.length === 0) return true
+  return only.some((one) => (at === one.under || at.startsWith(`${one.under}/`)) && at.endsWith(one.ending))
+}
+
+function listing(at: string, take: readonly string[], skip: readonly string[], only: readonly Wanted[], deep: number): readonly string[] {
+  const found: string[] = []
+  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: string): ts.ParseConfigHost {
+  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(): { readonly options: ts.CompilerOptions; readonly from: string; readonly trouble?: string } {
   for (const name of CONFIGS) {
     const at = join(ROOT, name)
-    if (!ts.sys.fileExists(at)) continue
+    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 },
@@ -212,7 +286,7 @@ export function configured(): { readonly options: ts.CompilerOptions; readonly f
       }
     }
 
-    const parsed = ts.parseJsonConfigFileContent(held.config as object, ts.sys, dirname(at))
+    const parsed = ts.parseJsonConfigFileContent(held.config as object, host, dirname(at))
     const complained = parsed.errors[0]
     if (complained !== undefined) {
       return {
@@ -227,13 +301,37 @@ export function configured(): { readonly options: ts.CompilerOptions; readonly f
   return { options: { ...FALLBACK, ...INVARIANT }, from: '' }
 }
 
+export function hosting(options: ts.CompilerOptions): ts.CompilerHost {
+  const host = ts.createCompilerHost(options, true)
+  const lib = host.getDefaultLibLocation?.()
+  const toolchain = (at: string): boolean => 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: { program: ts.Program; checker: ts.TypeChecker } | undefined
 
 function compiled(): { program: ts.Program; checker: ts.TypeChecker } {
   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
 }
@@ -659,6 +757,9 @@ export function forget(): void {
   scanned = undefined
   commands = undefined
   source.clear()
+  asked.clear()
+  ignores = undefined
+  readIgnores = false
 }
 
 export function descend(): Pass {
@@ -846,7 +947,10 @@ export function descend(): Pass {
       }
 
       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`,
@@ -857,14 +961,14 @@ export function descend(): Pass {
         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) {
           threaded.set(row.at, [...(threaded.get(row.at) ?? []), { list, by, row }])
           if (list === 'derives' && row.id !== undefined) derived.set(row.id, row)
         }
-        if (LISTS.some((name) => row.fields.has(name))) into(one, row.type, at, under, by, true)
+        if (LISTS.some((name) => row.fields.has(name))) 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)
       }
     }

package/dist/core/files.d.ts

@@ -0,0 +1,45 @@
+import * as disk from 'node:fs';
+export type Kind = 'file' | 'folder' | 'other' | 'none';
+export interface Listed {
+    readonly name: string;
+    readonly kind: Exclude<Kind, 'none'>;
+}
+export interface Measured {
+    readonly size: number;
+    readonly modified: number;
+}
+export interface Answering {
+    readonly kind: (at: string) => Kind;
+    readonly read: (at: string) => string;
+    readonly write: (at: string, said: string) => void;
+    readonly list: (at: string) => readonly Listed[];
+    readonly stat: (at: string) => Measured;
+    readonly remove: (at: string) => void;
+    readonly real: (at: string) => string;
+}
+export declare function answeredBy(one: Answering | undefined): void;
+export declare function attached(): boolean;
+export declare function kind(at: string): Kind;
+export declare function existsSync(at: disk.PathLike): boolean;
+export declare function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string;
+export declare function writeFileSync(at: disk.PathOrFileDescriptor, said: string, how?: BufferEncoding): void;
+export interface Named {
+    readonly name: string;
+    readonly isFile: () => boolean;
+    readonly isDirectory: () => boolean;
+}
+export declare function readdirSync(at: disk.PathLike): string[];
+export declare function readdirSync(at: disk.PathLike, how: {
+    readonly withFileTypes: true;
+}): readonly Named[];
+export interface Held extends Named, Measured {
+    readonly mtimeMs: number;
+}
+export declare function statSync(at: disk.PathLike): Held;
+export declare function statSync(at: disk.PathLike, how: {
+    readonly throwIfNoEntry: false;
+}): Held | undefined;
+export declare function rmSync(at: disk.PathLike, how?: disk.RmOptions): void;
+export declare function renameSync(from: disk.PathLike, to: disk.PathLike): void;
+export declare function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void;
+export declare function realpathSync(at: disk.PathLike): string;

package/dist/core/files.js

@@ -0,0 +1,95 @@
+import * as disk from 'node:fs';
+import { dirname } from 'node:path';
+let answering;
+export function answeredBy(one) {
+    answering = one;
+}
+const asked = (at) => (typeof at === 'string' ? answering : undefined);
+export function attached() {
+    return answering !== undefined;
+}
+export function kind(at) {
+    const one = answering;
+    if (one !== undefined)
+        return one.kind(at);
+    const held = disk.statSync(at, { throwIfNoEntry: false });
+    if (held === undefined)
+        return 'none';
+    return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other';
+}
+export function existsSync(at) {
+    return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at);
+}
+export function readFileSync(at, how) {
+    const one = asked(at);
+    return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at);
+}
+export function writeFileSync(at, said, how) {
+    const one = asked(at);
+    if (one !== undefined) {
+        one.write(at, said);
+        return;
+    }
+    if (typeof at === 'string')
+        disk.mkdirSync(dirname(at), { recursive: true });
+    disk.writeFileSync(at, said, how ?? 'utf8');
+}
+export function readdirSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how);
+    const held = one.list(at);
+    return how === undefined
+        ? held.map((each) => each.name)
+        : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }));
+}
+export function statSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        return (how === undefined ? disk.statSync(at) : disk.statSync(at, how));
+    const path = at;
+    const held = one.kind(path);
+    if (held === 'none') {
+        if (how !== undefined)
+            return undefined;
+        throw new Error(`${path} is not there, so nothing can be said about it.`);
+    }
+    const measured = one.stat(path);
+    return {
+        name: path,
+        size: measured.size,
+        modified: measured.modified,
+        mtimeMs: measured.modified,
+        isFile: () => held === 'file',
+        isDirectory: () => held === 'folder',
+    };
+}
+export function rmSync(at, how) {
+    const one = asked(at);
+    if (one === undefined)
+        disk.rmSync(at, how);
+    else
+        one.remove(at);
+}
+export function renameSync(from, to) {
+    const one = asked(from);
+    if (one === undefined) {
+        disk.renameSync(from, to);
+        return;
+    }
+    one.write(to, one.read(from));
+    one.remove(from);
+}
+export function appendFileSync(at, said) {
+    const one = asked(at);
+    if (one === undefined) {
+        disk.appendFileSync(at, said);
+        return;
+    }
+    const path = at;
+    one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`);
+}
+export function realpathSync(at) {
+    const one = asked(at);
+    return one === undefined ? disk.realpathSync(at) : one.real(at);
+}

package/dist/core/files.ts

@@ -0,0 +1,137 @@
+import * as disk from 'node:fs'
+import { dirname } from 'node:path'
+
+export type Kind = 'file' | 'folder' | 'other' | 'none'
+
+export interface Listed {
+  readonly name: string
+  readonly kind: Exclude<Kind, 'none'>
+}
+
+export interface Measured {
+  readonly size: number
+  readonly modified: number
+}
+
+export interface Answering {
+  readonly kind: (at: string) => Kind
+  readonly read: (at: string) => string
+  readonly write: (at: string, said: string) => void
+  readonly list: (at: string) => readonly Listed[]
+  readonly stat: (at: string) => Measured
+  readonly remove: (at: string) => void
+  readonly real: (at: string) => string
+}
+
+let answering: Answering | undefined
+
+export function answeredBy(one: Answering | undefined): void {
+  answering = one
+}
+
+const asked = (at: unknown): Answering | undefined => (typeof at === 'string' ? answering : undefined)
+
+export function attached(): boolean {
+  return answering !== undefined
+}
+
+export function kind(at: string): Kind {
+  const one = answering
+  if (one !== undefined) return one.kind(at)
+  const held = disk.statSync(at, { throwIfNoEntry: false })
+  if (held === undefined) return 'none'
+  return held.isFile() ? 'file' : held.isDirectory() ? 'folder' : 'other'
+}
+
+export function existsSync(at: disk.PathLike): boolean {
+  return typeof at === 'string' ? kind(at) !== 'none' : disk.existsSync(at)
+}
+
+export function readFileSync(at: disk.PathOrFileDescriptor, how?: BufferEncoding): string {
+  const one = asked(at)
+  return one === undefined ? disk.readFileSync(at, how ?? 'utf8') : one.read(at as string)
+}
+
+export function writeFileSync(at: disk.PathOrFileDescriptor, said: string, how?: BufferEncoding): void {
+  const one = asked(at)
+  if (one !== undefined) {
+    one.write(at as string, said)
+    return
+  }
+  if (typeof at === 'string') disk.mkdirSync(dirname(at), { recursive: true })
+  disk.writeFileSync(at, said, how ?? 'utf8')
+}
+
+export interface Named {
+  readonly name: string
+  readonly isFile: () => boolean
+  readonly isDirectory: () => boolean
+}
+
+export function readdirSync(at: disk.PathLike): string[]
+export function readdirSync(at: disk.PathLike, how: { readonly withFileTypes: true }): readonly Named[]
+export function readdirSync(at: disk.PathLike, how?: { readonly withFileTypes: true }): string[] | readonly Named[] {
+  const one = asked(at)
+  if (one === undefined) return how === undefined ? disk.readdirSync(at) : disk.readdirSync(at, how)
+  const held = one.list(at as string)
+  return how === undefined
+    ? held.map((each) => each.name)
+    : held.map((each) => ({ name: each.name, isFile: () => each.kind === 'file', isDirectory: () => each.kind === 'folder' }))
+}
+
+export interface Held extends Named, Measured {
+  readonly mtimeMs: number
+}
+
+export function statSync(at: disk.PathLike): Held
+export function statSync(at: disk.PathLike, how: { readonly throwIfNoEntry: false }): Held | undefined
+export function statSync(at: disk.PathLike, how?: { readonly throwIfNoEntry: false }): Held | undefined {
+  const one = asked(at)
+  if (one === undefined) return (how === undefined ? disk.statSync(at) : disk.statSync(at, how)) as Held | undefined
+  const path = at as string
+  const held = one.kind(path)
+  if (held === 'none') {
+    if (how !== undefined) return undefined
+    throw new Error(`${path} is not there, so nothing can be said about it.`)
+  }
+  const measured = one.stat(path)
+  return {
+    name: path,
+    size: measured.size,
+    modified: measured.modified,
+    mtimeMs: measured.modified,
+    isFile: () => held === 'file',
+    isDirectory: () => held === 'folder',
+  }
+}
+
+export function rmSync(at: disk.PathLike, how?: disk.RmOptions): void {
+  const one = asked(at)
+  if (one === undefined) disk.rmSync(at, how)
+  else one.remove(at as string)
+}
+
+export function renameSync(from: disk.PathLike, to: disk.PathLike): void {
+  const one = asked(from)
+  if (one === undefined) {
+    disk.renameSync(from, to)
+    return
+  }
+  one.write(to as string, one.read(from as string))
+  one.remove(from as string)
+}
+
+export function appendFileSync(at: disk.PathOrFileDescriptor, said: string): void {
+  const one = asked(at)
+  if (one === undefined) {
+    disk.appendFileSync(at, said)
+    return
+  }
+  const path = at as string
+  one.write(path, `${one.kind(path) === 'none' ? '' : one.read(path)}${said}`)
+}
+
+export function realpathSync(at: disk.PathLike): string {
+  const one = asked(at)
+  return one === undefined ? disk.realpathSync(at as string) : one.real(at as string)
+}

package/dist/core/init.d.ts

@@ -6,6 +6,7 @@ export declare class AlreadyThreadedError extends Error {
 }
 export declare const COMPILER = "tsconfig.json";
 export declare const LOCKFILES: readonly ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+export declare function manager(into: string): readonly string[];
 export declare const MANIFEST = "package.json";
 export declare const REGISTRY: string;
 export declare const IGNORED: string;

package/dist/core/init.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from "./files.js";
 import { join, relative, resolve } from 'node:path';
 import { quoted } from "./rows.js";
 export const TREE = '_threads';
@@ -15,6 +15,15 @@ export class AlreadyThreadedError extends Error {
 }
 export const COMPILER = 'tsconfig.json';
 export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'];
+export function manager(into) {
+    if (existsSync(join(into, 'pnpm-lock.yaml')))
+        return ['pnpm', 'add'];
+    if (existsSync(join(into, 'yarn.lock')))
+        return ['yarn', 'add'];
+    if (existsSync(join(into, 'bun.lockb')))
+        return ['bun', 'add'];
+    return ['npm', 'install'];
+}
 export const MANIFEST = 'package.json';
 const MODULE = 'module';
 export const REGISTRY = '.npm' + 'rc';
@@ -104,7 +113,6 @@ export function init(into) {
     const at = join(dir, ROOT);
     if (existsSync(at))
         throw new AlreadyThreadedError(relative(into, at));
-    mkdirSync(dir, { recursive: true });
     const written = [];
     const held = join(into, COMPILER);
     if (!existsSync(held)) {

package/dist/core/init.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, writeFileSync } from './files.ts'
 import { join, relative, resolve } from 'node:path'
 
 import { quoted } from './rows.ts'
@@ -24,6 +24,13 @@ export const COMPILER = 'tsconfig.json'
 
 export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'] as const
 
+export function manager(into: string): readonly string[] {
+  if (existsSync(join(into, 'pnpm-lock.yaml'))) return ['pnpm', 'add']
+  if (existsSync(join(into, 'yarn.lock'))) return ['yarn', 'add']
+  if (existsSync(join(into, 'bun.lockb'))) return ['bun', 'add']
+  return ['npm', 'install']
+}
+
 export const MANIFEST = 'package.json'
 
 const MODULE = 'module'
@@ -134,7 +141,6 @@ export function init(into: string): readonly string[] {
   const dir = resolve(into, TREE)
   const at = join(dir, ROOT)
   if (existsSync(at)) throw new AlreadyThreadedError(relative(into, at))
-  mkdirSync(dir, { recursive: true })
   const written: string[] = []
 
   const held = join(into, COMPILER)

package/dist/core/invoked.js

@@ -21,7 +21,7 @@ export const BESIDE = (name) => `${name}${SOURCE ? '.ts' : '.js'}`;
 export const LOADER = SOURCE ? ['--import', 'tsx'] : [];
 export const CLI = [
     ...LOADER,
-    join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+    join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'cli', BESIDE('cli')),
 ];
 export const REFUSED = Symbol.for('thread.refused');
 let sharing = false;

package/dist/core/invoked.ts

@@ -24,7 +24,7 @@ export const LOADER: readonly string[] = SOURCE ? ['--import', 'tsx'] : []
 
 export const CLI: readonly string[] = [
   ...LOADER,
-  join(dirname(fileURLToPath(import.meta.url)), BESIDE('cli')),
+  join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'cli', BESIDE('cli')),
 ]
 
 export const REFUSED = Symbol.for('thread.refused')

package/dist/core/rows.d.ts

@@ -18,6 +18,8 @@ export declare function withRequires(text: string, where: Bounds, id: string, re
 export declare function seedsIn(text: string, where: Bounds, id: string): Bounds | undefined;
 export declare function afterRow(text: string, where: Bounds, follows: string, row: string): string | undefined;
 export declare const quoted: (one: string) => string;
+export declare function valuesIn(text: string): Readonly<Record<string, unknown>>;
+export declare function unread(text: string): readonly string[];
 export declare const STATED: string[];
 export declare function reconciled(held: string, source: string, fields: readonly string[]): string;
 export declare function fieldIn(text: string, where: Bounds, id: string, field: string): string | undefined;

package/dist/core/rows.js

@@ -239,6 +239,71 @@ function stated(node, field) {
     return undefined;
 }
 export const quoted = (one) => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`;
+const UNREAD = Symbol.for('thread.unread');
+function valued(node) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    if (ts.isNumericLiteral(node))
+        return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node))
+        return valued(node.expression);
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
+        const held = valued(node.operand);
+        return typeof held === 'number' ? -held : UNREAD;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const held = [];
+        for (const one of node.elements) {
+            const each = valued(one);
+            if (each === UNREAD)
+                return UNREAD;
+            held.push(each);
+        }
+        return held;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const held = {};
+        for (const one of node.properties) {
+            if (!ts.isPropertyAssignment(one))
+                return UNREAD;
+            const key = keyed(one);
+            if (key === undefined)
+                return UNREAD;
+            const each = valued(one.initializer);
+            if (each === UNREAD)
+                return UNREAD;
+            held[key] = each;
+        }
+        return held;
+    }
+    return UNREAD;
+}
+function taken(text) {
+    const found = [];
+    walk(tree(text), (node) => {
+        if (!ts.isVariableDeclaration(node) || node.initializer === undefined || !ts.isIdentifier(node.name))
+            return;
+        found.push([node.name.text, valued(node.initializer)]);
+    });
+    return found;
+}
+export function valuesIn(text) {
+    const found = {};
+    for (const [name, held] of taken(text)) {
+        if (held !== UNREAD)
+            found[name] = held;
+    }
+    return found;
+}
+export function unread(text) {
+    return taken(text).filter(([, held]) => held === UNREAD).map(([name]) => name);
+}
 export const STATED = ['at', 'describes', 'version'];
 export function reconciled(held, source, fields) {
     const ships = headed(source);