@prestack/thread 0.1.3 → 0.1.5

package/dist/core/errors/namespaces.js

@@ -0,0 +1,15 @@
+export const NAMESPACES = [
+    'auth',
+    'quota',
+    'rate_limit',
+    'feature',
+    'db',
+    'workflow',
+    'queue',
+    'ai',
+    'search',
+    'comms',
+    'config',
+    'net',
+    'internal',
+];

package/dist/core/errors/namespaces.ts

@@ -0,0 +1,19 @@
+export const NAMESPACES = [
+  'auth',
+  'quota',
+  'rate_limit',
+  'feature',
+  'db',
+  'workflow',
+  'queue',
+  'ai',
+  'search',
+  'comms',
+  'config',
+  'net',
+  'internal',
+] as const
+
+export type Namespace = (typeof NAMESPACES)[number]
+
+export type ErrorCode = `${Namespace}.${string}`

package/dist/core/finding.js

@@ -11,7 +11,6 @@ function locate(finding) {
 export function runChecker(name, findings, measured) {
     if (findings.length === 0) {
         stdout.write(`${name}: ${measured} — no findings.\n`);
-        process.exitCode = 0;
         return;
     }
     const lines = findings.map((finding) => `  ${forbids(finding) ? '' : 'warning: '}${finding.detail}${locate(finding)}\n    Instead: ${finding.instead}`);
@@ -19,5 +18,6 @@ export function runChecker(name, findings, measured) {
     stdout.write(`${name}: ${String(findings.length)} finding${findings.length === 1 ? '' : 's'}` +
         `${forbidding === findings.length ? '' : `, ${String(findings.length - forbidding)} of them warnings`} — ${measured}\n\n` +
         `${lines.join('\n')}\n`);
-    process.exitCode = forbidding === 0 ? 0 : 1;
+    if (forbidding > 0)
+        process.exitCode = 1;
 }

package/dist/core/finding.ts

@@ -21,7 +21,6 @@ function locate(finding: Finding): string {
 export function runChecker(name: string, findings: readonly Finding[], measured: string): void {
   if (findings.length === 0) {
     stdout.write(`${name}: ${measured} — no findings.\n`)
-    process.exitCode = 0
     return
   }
 
@@ -34,5 +33,5 @@ export function runChecker(name: string, findings: readonly Finding[], measured:
       `${forbidding === findings.length ? '' : `, ${String(findings.length - forbidding)} of them warnings`} — ${measured}\n\n` +
       `${lines.join('\n')}\n`,
   )
-  process.exitCode = forbidding === 0 ? 0 : 1
+  if (forbidding > 0) process.exitCode = 1
 }

package/dist/core/init.d.ts

@@ -1,11 +1,11 @@
 export declare const TREE = "_threads";
 export declare const ROOT = "thread.ts";
+export declare const SHAPED = "@prestack/thread/core/thread";
 export declare class AlreadyThreadedError extends Error {
     readonly at: string;
     constructor(at: string);
 }
 export declare const COMPILER = "tsconfig.json";
-export declare const LOCKFILES: readonly ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
 export declare const MANIFEST = "package.json";
 export declare const REGISTRY: string;
 export declare const IGNORED: string;

package/dist/core/init.js

@@ -1,8 +1,13 @@
-import { existsSync, readFileSync, writeFileSync } from "./files.js";
+import { LOCKFILES, installing, manager } from '../integrations/cli.js';
+import { existsSync, readFileSync, writeFileSync } from '../integrations/disk.js';
+import { createRequire } from 'node:module';
 import { join, relative, resolve } from 'node:path';
-import { quoted } from "./rows.js";
+import { fileURLToPath } from 'node:url';
+import { quoted } from './rows.js';
+import { NAMED } from './scope.js';
 export const TREE = '_threads';
 export const ROOT = 'thread.ts';
+export const SHAPED = `${NAMED}/core/thread`;
 export class AlreadyThreadedError extends Error {
     at;
     constructor(at) {
@@ -14,9 +19,11 @@ export class AlreadyThreadedError extends Error {
     }
 }
 export const COMPILER = 'tsconfig.json';
-export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'];
 export const MANIFEST = 'package.json';
+const BUILT = '_gener' + 'ated/packages/core';
 const MODULE = 'module';
+const NPM = 'npm';
+const LATEST = 'latest';
 export const REGISTRY = '.npm' + 'rc';
 export const IGNORED = '.git' + 'ignore';
 export function ignored() {
@@ -46,7 +53,7 @@ export function compiler() {
     }, null, 2)}\n`;
 }
 function owned(into) {
-    const held = LOCKFILES.filter((one) => existsSync(join(into, one)));
+    const held = Object.keys(LOCKFILES).filter((one) => existsSync(join(into, one)));
     return [
         {
             id: 'manifest',
@@ -85,7 +92,7 @@ export function root(into) {
         '    },',
     ]);
     return [
-        "import type { Threaded } from './thread.ts'",
+        `import type { Threaded } from '${SHAPED}'`,
         '',
         'export const THREAD: Threaded = {',
         "  id: 'thread',",
@@ -99,6 +106,35 @@ export function root(into) {
         '',
     ].join('\n');
 }
+const own = createRequire(import.meta.url);
+function manifested(at) {
+    try {
+        return own(at);
+    }
+    catch {
+        return undefined;
+    }
+}
+function shipped() {
+    let at = fileURLToPath(new URL('.', import.meta.url));
+    for (;;) {
+        const read = manifested(join(at, MANIFEST));
+        if (read !== undefined) {
+            if (read.name !== undefined && read.version !== undefined)
+                return [read.name, read.version];
+            const core = manifested(join(at, BUILT, MANIFEST));
+            if (core?.name !== undefined && core.version !== undefined)
+                return [core.name, core.version];
+        }
+        const up = resolve(at, '..');
+        if (up === at) {
+            throw new Error('this framework cannot find the package it is running from, so it has no name to install into your project. ' +
+                'That name is read off the manifest beside this code rather than written down anywhere, which is what keeps it ' +
+                'right when the package is renamed.');
+        }
+        at = up;
+    }
+}
 export function init(into) {
     const dir = resolve(into, TREE);
     const at = join(dir, ROOT);
@@ -121,11 +157,21 @@ export function init(into) {
         writeFileSync(manifest, `${JSON.stringify({ ...stated, type: MODULE }, null, 2)}\n`, 'utf8');
         written.push(MANIFEST);
     }
+    const [from, version] = shipped();
+    const holds = JSON.parse(readFileSync(manifest, 'utf8'));
+    const dev = holds.devDependencies ?? {};
+    const wanted = { [from]: '^' + version, ...(manager(into) === NPM ? { [NPM]: LATEST } : {}) };
+    const missing = Object.entries(wanted).filter(([name]) => dev[name] === undefined);
+    if (missing.length > 0) {
+        writeFileSync(manifest, JSON.stringify({ ...holds, devDependencies: { ...dev, ...Object.fromEntries(missing) } }, null, 2) + '\n', 'utf8');
+        written.push(MANIFEST);
+    }
     const ignore = join(into, IGNORED);
     if (!existsSync(ignore)) {
         writeFileSync(ignore, ignored(), 'utf8');
         written.push(IGNORED);
     }
+    installing(into);
     for (const [name, text] of [[ROOT, root(into)]]) {
         writeFileSync(join(dir, name), text, 'utf8');
         written.push(relative(into, join(dir, name)));

package/dist/core/init.ts

@@ -1,12 +1,18 @@
-import { existsSync, readFileSync, writeFileSync } from './files.ts'
+import { LOCKFILES, installing, manager } from '../integrations/cli.ts'
+import { existsSync, readFileSync, writeFileSync } from '../integrations/disk.ts'
+import { createRequire } from 'node:module'
 import { join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import { quoted } from './rows.ts'
+import { NAMED } from './scope.ts'
 
 
 export const TREE = '_threads'
 export const ROOT = 'thread.ts'
 
+export const SHAPED = `${NAMED}/core/thread`
+
 export class AlreadyThreadedError extends Error {
   readonly at: string
   constructor(at: string) {
@@ -23,12 +29,16 @@ export class AlreadyThreadedError extends Error {
 
 export const COMPILER = 'tsconfig.json'
 
-export const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lockb'] as const
-
 export const MANIFEST = 'package.json'
 
+const BUILT = '_gener' + 'ated/packages/core'
+
 const MODULE = 'module'
 
+const NPM = 'npm'
+
+const LATEST = 'latest'
+
 export const REGISTRY = '.npm' + 'rc'
 
 export const IGNORED = '.git' + 'ignore'
@@ -71,7 +81,7 @@ export function compiler(): string {
 }
 
 function owned(into: string): readonly { readonly id: string; readonly at: string; readonly describes: string; readonly runs?: string }[] {
-  const held = LOCKFILES.filter((one) => existsSync(join(into, one)))
+  const held = Object.keys(LOCKFILES).filter((one) => existsSync(join(into, one)))
   return [
     {
       id: 'manifest',
@@ -116,7 +126,7 @@ export function root(into: string): string {
     '    },',
   ])
   return [
-    "import type { Threaded } from './thread.ts'",
+    `import type { Threaded } from '${SHAPED}'`,
     '',
     'export const THREAD: Threaded = {',
     "  id: 'thread',",
@@ -131,6 +141,37 @@ export function root(into: string): string {
   ].join('\n')
 }
 
+const own = createRequire(import.meta.url)
+
+function manifested(at: string): { readonly name?: string; readonly version?: string } | undefined {
+  try {
+    return own(at) as { readonly name?: string; readonly version?: string }
+  } catch {
+    return undefined
+  }
+}
+
+function shipped(): readonly [string, string] {
+  let at = fileURLToPath(new URL('.', import.meta.url))
+  for (;;) {
+    const read = manifested(join(at, MANIFEST))
+    if (read !== undefined) {
+      if (read.name !== undefined && read.version !== undefined) return [read.name, read.version]
+      const core = manifested(join(at, BUILT, MANIFEST))
+      if (core?.name !== undefined && core.version !== undefined) return [core.name, core.version]
+    }
+    const up = resolve(at, '..')
+    if (up === at) {
+      throw new Error(
+        'this framework cannot find the package it is running from, so it has no name to install into your project. ' +
+          'That name is read off the manifest beside this code rather than written down anywhere, which is what keeps it ' +
+          'right when the package is renamed.',
+      )
+    }
+    at = up
+  }
+}
+
 export function init(into: string): readonly string[] {
   const dir = resolve(into, TREE)
   const at = join(dir, ROOT)
@@ -155,12 +196,24 @@ export function init(into: string): readonly string[] {
     written.push(MANIFEST)
   }
 
+  const [from, version] = shipped()
+  const holds = JSON.parse(readFileSync(manifest, 'utf8')) as { devDependencies?: Record<string, string> }
+  const dev = holds.devDependencies ?? {}
+  const wanted: Readonly<Record<string, string>> = { [from]: '^' + version, ...(manager(into) === NPM ? { [NPM]: LATEST } : {}) }
+  const missing = Object.entries(wanted).filter(([name]) => dev[name] === undefined)
+  if (missing.length > 0) {
+    writeFileSync(manifest, JSON.stringify({ ...holds, devDependencies: { ...dev, ...Object.fromEntries(missing) } }, null, 2) + '\n', 'utf8')
+    written.push(MANIFEST)
+  }
+
   const ignore = join(into, IGNORED)
   if (!existsSync(ignore)) {
     writeFileSync(ignore, ignored(), 'utf8')
     written.push(IGNORED)
   }
 
+  installing(into)
+
   for (const [name, text] of [[ROOT, root(into)]] as const) {
     writeFileSync(join(dir, name), text, 'utf8')
     written.push(relative(into, join(dir, name)))

package/dist/core/invoked.d.ts

@@ -4,6 +4,6 @@ export declare const BESIDE: (name: string) => string;
 export declare const LOADER: readonly string[];
 export declare const CLI: readonly string[];
 export declare const REFUSED: unique symbol;
-export declare const shared: (on: boolean) => void;
+export declare const shared: (on: boolean) => boolean;
 export declare function exit(code?: number): never;
 export declare const refusal: (thrown: unknown) => number | undefined;

package/dist/core/invoked.js

@@ -1,7 +1,7 @@
-import { realpathSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { argv, exit as ending } from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { realpathSync } from '../integrations/disk.js';
 export function invoked(url) {
     const named = argv[1];
     if (named === undefined)
@@ -26,7 +26,9 @@ export const CLI = [
 export const REFUSED = Symbol.for('thread.refused');
 let sharing = false;
 export const shared = (on) => {
+    const was = sharing;
     sharing = on;
+    return was;
 };
 export function exit(code) {
     if (!sharing)

package/dist/core/invoked.ts

@@ -1,8 +1,9 @@
-import { realpathSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { argv, exit as ending } from 'node:process'
 import { fileURLToPath } from 'node:url'
 
+import { realpathSync } from '../integrations/disk.ts'
+
 export function invoked(url: string): boolean {
   const named = argv[1]
   if (named === undefined) return false
@@ -31,8 +32,10 @@ export const REFUSED = Symbol.for('thread.refused')
 
 let sharing = false
 
-export const shared = (on: boolean): void => {
+export const shared = (on: boolean): boolean => {
+  const was = sharing
   sharing = on
+  return was
 }
 
 export function exit(code?: number): never {

package/dist/core/round.js

@@ -7,17 +7,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { resolve } from 'node:path';
-import { argv, exitCode, stdout } from 'node:process';
+import { argv, exitCode, stderr, stdout } from 'node:process';
 import { pathToFileURL } from 'node:url';
-import { generators, RAN, REFUSED_BY } from "./chain.js";
-import { forget } from "./descend.js";
-import { refusal, shared } from "./invoked.js";
-import { findTree } from "./tree.js";
+import { generators, RAN, REFUSED_BY } from './chain.js';
+import { attached, here } from '../integrations/disk.js';
+import { forget } from './descend.js';
+import { refusal, shared } from './invoked.js';
+import { findTree } from './tree.js';
 let spun = 0;
 const words = (command) => command.trim().split(/\s+/).slice(1);
 shared(true);
 const tree = findTree();
 const rows = await generators(tree);
+let stale = true;
 for (const command of argv.slice(2).filter((one) => one !== '')) {
     const said = words(command);
     const name = said[0];
@@ -25,33 +27,45 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
         continue;
     const held = rows.find((one) => one.by === `thread ${name}`);
     if (held?.at === undefined) {
-        stdout.write(`${REFUSED_BY} ${command}\n`);
         stdout.write(`round: no command named "${name}", so \`${command}\` was not run\n`);
+        stdout.write(`${REFUSED_BY} ${command}\n`);
         continue;
     }
     const found = resolve(tree.at, held.at);
-    forget();
+    if (stale)
+        forget();
     argv.length = 1;
     argv.push(found, ...said.slice(1));
     spun += 1;
     process.exitCode = 0;
-    try {
-        await import(__rewriteRelativeImportExtension(`${pathToFileURL(found).href}?round=${String(spun)}`));
-        if (exitCode !== undefined && exitCode !== 0)
-            stdout.write(`${REFUSED_BY} ${command}\n`);
-        else
-            stdout.write(`${RAN} ${command}\n`);
+    const began = Date.now();
+    stderr.write(`settle: running ${command}\n`);
+    let ok = true;
+    const ran = attached() ? here().run(found, said.slice(1)) : undefined;
+    if (ran !== undefined) {
+        stdout.write(ran.out);
+        stderr.write(ran.err);
+        ok = ran.there && ran.ok;
+        if (!ran.there)
+            stdout.write('round: ' + command + ' could not be started where the tree is: ' + ran.why + '\n');
     }
-    catch (thrown) {
-        const code = refusal(thrown);
-        if (code === undefined) {
-            stdout.write(`${REFUSED_BY} ${command}\n`);
-            stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
+    else {
+        try {
+            await import(__rewriteRelativeImportExtension(`${pathToFileURL(found).href}?round=${String(spun)}`));
+            ok = exitCode === undefined || exitCode === 0;
+        }
+        catch (thrown) {
+            const code = refusal(thrown);
+            if (code === undefined) {
+                ok = false;
+                stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`);
+            }
+            else
+                ok = code === 0;
         }
-        else if (code === 0)
-            stdout.write(`${RAN} ${command}\n`);
-        else
-            stdout.write(`${REFUSED_BY} ${command}\n`);
     }
+    stdout.write(`${ok ? RAN : REFUSED_BY} ${command}\n`);
+    stderr.write(`settle: ${command} — ${String(Date.now() - began)} ms, ${ok ? 'ran' : 'refused'}\n`);
+    stale = !command.trim().endsWith('--check');
 }
 process.exitCode = 0;

package/dist/core/round.ts

@@ -1,8 +1,9 @@
 import { resolve } from 'node:path'
-import { argv, exitCode, stdout } from 'node:process'
+import { argv, exitCode, stderr, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
 
 import { generators, RAN, REFUSED_BY } from './chain.ts'
+import { attached, here } from '../integrations/disk.ts'
 import { forget } from './descend.ts'
 import { refusal, shared } from './invoked.ts'
 import { findTree } from './tree.ts'
@@ -16,6 +17,8 @@ shared(true)
 const tree = findTree()
 const rows = await generators(tree)
 
+let stale = true
+
 for (const command of argv.slice(2).filter((one) => one !== '')) {
   const said = words(command)
   const name = said[0]
@@ -23,14 +26,14 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
 
   const held = rows.find((one) => one.by === `thread ${name}`)
   if (held?.at === undefined) {
-    stdout.write(`${REFUSED_BY} ${command}\n`)
     stdout.write(`round: no command named "${name}", so \`${command}\` was not run\n`)
+    stdout.write(`${REFUSED_BY} ${command}\n`)
     continue
   }
 
   const found = resolve(tree.at, held.at)
 
-  forget()
+  if (stale) forget()
 
   argv.length = 1
   argv.push(found, ...said.slice(1))
@@ -39,19 +42,33 @@ for (const command of argv.slice(2).filter((one) => one !== '')) {
 
   process.exitCode = 0
 
+  const began = Date.now()
+  stderr.write(`settle: running ${command}\n`)
+
+  let ok = true
+  const ran = attached() ? here().run(found, said.slice(1)) : undefined
+  if (ran !== undefined) {
+    stdout.write(ran.out)
+    stderr.write(ran.err)
+    ok = ran.there && ran.ok
+    if (!ran.there) stdout.write('round: ' + command + ' could not be started where the tree is: ' + ran.why + '\n')
+  } else {
   try {
     await import(`${pathToFileURL(found).href}?round=${String(spun)}`)
-    if (exitCode !== undefined && exitCode !== 0) stdout.write(`${REFUSED_BY} ${command}\n`)
-    else stdout.write(`${RAN} ${command}\n`)
+    ok = exitCode === undefined || exitCode === 0
   } catch (thrown) {
     const code = refusal(thrown)
     if (code === undefined) {
-
-      stdout.write(`${REFUSED_BY} ${command}\n`)
+      ok = false
       stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`)
-    } else if (code === 0) stdout.write(`${RAN} ${command}\n`)
-    else stdout.write(`${REFUSED_BY} ${command}\n`)
+    } else ok = code === 0
+  }
   }
+
+  stdout.write(`${ok ? RAN : REFUSED_BY} ${command}\n`)
+  stderr.write(`settle: ${command} — ${String(Date.now() - began)} ms, ${ok ? 'ran' : 'refused'}\n`)
+
+  stale = !command.trim().endsWith('--check')
 }
 
 process.exitCode = 0

package/dist/core/rows.d.ts

@@ -5,6 +5,7 @@ export interface Bounds {
 export declare function inCode(text: string): readonly boolean[];
 export declare function matched(text: string, code: readonly boolean[], from: number, open: string, close: string): number;
 export declare function listBounds(text: string, list: string): Bounds | undefined;
+export declare function nestedBounds(text: string, where: Bounds, parent: string, list: string): Bounds | undefined;
 export declare function holdsRow(text: string, where: Bounds, id: string): boolean;
 export declare function seededAt(text: string, where: Bounds, id: string): string | undefined;
 export declare function rowsIn(text: string, where: Bounds): readonly {
@@ -24,5 +25,8 @@ 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;
 export declare function withField(text: string, where: Bounds, id: string, field: string, value: string): string | undefined;
+export declare function withTopField(text: string, field: string, value: string): string | undefined;
+export declare function withoutField(text: string, where: Bounds, id: string, field: string): string;
 export declare function withoutRow(text: string, where: Bounds, id: string): string;
+export declare function marked(parts: readonly string[]): string;
 export declare function showing(row: object, only?: readonly string[]): string;

package/dist/core/rows.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import ts from 'typescript';
 const PARSED = new Map();
 function tree(text) {
@@ -109,6 +110,13 @@ export function listBounds(text, list) {
     const inside = listy(held, list);
     return inside === undefined ? undefined : spanned(inside);
 }
+export function nestedBounds(text, where, parent, list) {
+    const row = rowAt(text, where, parent);
+    if (row === undefined)
+        return undefined;
+    const inside = listy(row, list);
+    return inside === undefined ? undefined : spanned(inside);
+}
 function elements(text, where) {
     let found;
     walk(tree(text), (node) => {
@@ -341,8 +349,26 @@ export function fieldIn(text, where, id, field) {
 }
 export function withField(text, where, id, field, value) {
     const held = rowAt(text, where, id);
-    if (held === undefined)
-        return undefined;
+    return held === undefined ? undefined : fieldOn(text, held, field, value);
+}
+export function withTopField(text, field, value) {
+    const held = headed(text);
+    return held === undefined ? undefined : fieldOn(text, held, field, value);
+}
+export function withoutField(text, where, id, field) {
+    const held = rowAt(text, where, id);
+    const one = held?.properties.find((each) => ts.isPropertyAssignment(each) && keyed(each) === field);
+    if (held === undefined || one === undefined)
+        return text;
+    let ends = one.getEnd();
+    if (text[ends] === ',')
+        ends += 1;
+    const line = text.lastIndexOf('\n', one.getStart());
+    if (line > held.getStart())
+        return text.slice(0, line) + text.slice(ends);
+    return text.slice(0, one.getStart()) + text.slice(text[ends] === ' ' ? ends + 1 : ends);
+}
+function fieldOn(text, held, field, value) {
     for (const one of held.properties) {
         if (!ts.isPropertyAssignment(one) || keyed(one) !== field)
             continue;
@@ -403,6 +429,9 @@ const lines = (held, pad) => {
     }
     return [String(held)];
 };
+export function marked(parts) {
+    return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6);
+}
 export function showing(row, only = []) {
     const held = row;
     const keys = Object.keys(held);

package/dist/core/rows.ts

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto'
+
 import ts from 'typescript'
 
 export interface Bounds {
@@ -117,6 +119,13 @@ export function listBounds(text: string, list: string): Bounds | undefined {
   return inside === undefined ? undefined : spanned(inside)
 }
 
+export function nestedBounds(text: string, where: Bounds, parent: string, list: string): Bounds | undefined {
+  const row = rowAt(text, where, parent)
+  if (row === undefined) return undefined
+  const inside = listy(row, list)
+  return inside === undefined ? undefined : spanned(inside)
+}
+
 function elements(text: string, where: Bounds): readonly ts.ObjectLiteralExpression[] {
   let found: ts.ArrayLiteralExpression | undefined
   walk(tree(text), (node) => {
@@ -351,7 +360,26 @@ export function withField(
   value: string,
 ): string | undefined {
   const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
+  return held === undefined ? undefined : fieldOn(text, held, field, value)
+}
+
+export function withTopField(text: string, field: string, value: string): string | undefined {
+  const held = headed(text)
+  return held === undefined ? undefined : fieldOn(text, held, field, value)
+}
+
+export function withoutField(text: string, where: Bounds, id: string, field: string): string {
+  const held = rowAt(text, where, id)
+  const one = held?.properties.find((each) => ts.isPropertyAssignment(each) && keyed(each) === field)
+  if (held === undefined || one === undefined) return text
+  let ends = one.getEnd()
+  if (text[ends] === ',') ends += 1
+  const line = text.lastIndexOf('\n', one.getStart())
+  if (line > held.getStart()) return text.slice(0, line) + text.slice(ends)
+  return text.slice(0, one.getStart()) + text.slice(text[ends] === ' ' ? ends + 1 : ends)
+}
+
+function fieldOn(text: string, held: ts.ObjectLiteralExpression, field: string, value: string): string | undefined {
   for (const one of held.properties) {
     if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
     return `${text.slice(0, one.initializer.getStart())}${value}${text.slice(one.initializer.getEnd())}`
@@ -409,6 +437,10 @@ const lines = (held: unknown, pad: string): readonly string[] => {
   return [String(held)]
 }
 
+export function marked(parts: readonly string[]): string {
+  return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6)
+}
+
 export function showing(row: object, only: readonly string[] = []): string {
   const held = row as Record<string, unknown>
   const keys = Object.keys(held)

package/dist/core/scope.d.ts

@@ -4,3 +4,4 @@ export declare const NAMED = "@prestack/thread";
 export declare const named: (id: string) => string;
 export declare const idOf: (name: string) => string | undefined;
 export declare const ours: (name: string) => boolean;
+export declare const installed: (at: string) => boolean;

package/dist/core/scope.js

@@ -10,3 +10,4 @@ export const idOf = (name) => {
     return name.startsWith(HEAD) ? name.slice(HEAD.length) : undefined;
 };
 export const ours = (name) => idOf(name) !== undefined;
+export const installed = (at) => at.startsWith('node_modules/') && ours(at.split('/').slice(1, 3).join('/'));