@prestack/thread 0.1.19 → 0.1.21

package/dist/integrations/cli.js

@@ -6,11 +6,10 @@ import { allowedNodeEnvironmentFlags, env, execPath, kill, pid, stderr, stdout }
 import { fileURLToPath } from 'node:url';
 import { CHANNEL, FOLDER, across, attached, createFileSync, existsSync, here, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from '../integrations/disk.js';
 import { VAULT_DIR } from '../integrations/vault.js';
-import { CALL_PREFIX, LOCKFILES, ORDERS, PACKAGER, REACH, managerOf, programOf, unlisted } from '../integrations/target.js';
+import { LOCKFILES, ORDERS, PACKAGER, REACH, managerOf, programOf, unlisted } from '../integrations/target.js';
 import { BESIDE, CLI } from '../core/invoked.js';
-import { valuesIn } from '../core/rows.js';
 import { THING } from '../core/scope.js';
-import { findTree, inTree } from '../core/tree.js';
+import { findTree } from '../core/tree.js';
 const answered = (went) => ({
     there: went.error === undefined,
     ok: went.status === 0,
@@ -141,7 +140,7 @@ export function claims(root, runs) {
     return { by: { pid: 0, runs: '', since: Date.now() } };
 }
 export function programFor(name, at) {
-    const found = programOf(name, at, existsSync);
+    const found = programOf(name, at, existsSync, (path) => readFileSync(path, 'utf8'));
     if (found === undefined)
         throw new Error(unlisted(name));
     return found;
@@ -170,6 +169,7 @@ export function signing() {
 const OWN = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 export const PROGRAM = REACH.cli + THING;
 export const COPIES = THING + ' create copy';
+export const COPY_AT = join(VAULT_DIR, THING + '.json');
 const UNCOPIED = 'the thread command sits beside none of the framework code this server runs, because no package ships it, and the ' +
     'folder this server was started from keeps no compiled copy of it. Run `' + COPIES + '` in that folder from a server ' +
     'that runs the framework itself, and the next command here starts that copy.';
@@ -187,10 +187,10 @@ function startable() {
     catch {
         return UNCOPIED;
     }
-    const copied = ((sheet(root).TARGETS ?? []).find((one) => one.id === PROGRAM)?.derives ?? []).find((one) => one.by === COPIES)?.at;
-    if (copied === undefined || !existsSync(resolve(root, copied)))
+    const copied = resolve(root, COPY_AT);
+    if (!existsSync(copied))
         return UNCOPIED;
-    const said = readFileSync(resolve(root, copied), 'utf8');
+    const said = readFileSync(copied, 'utf8');
     const own = join(root, CACHED, createHash('sha256').update(said).digest('hex').slice(0, 16));
     const entry = join(own, 'cli', BESIDE('cli'));
     if (!existsSync(entry)) {
@@ -245,6 +245,23 @@ const READS = new Set(Object.entries(ORDERS).filter(([order, answer]) => order =
 function kept(one, asked, held) {
     if (READS.has(asked.order) && held.answered !== 'refused')
         one.known.set(told(asked), held);
+    if (asked.order !== 'write' || held.answered !== ORDERS.write)
+        return;
+    one.known.set(told({ order: 'read', at: asked.at }), { answered: 'read', said: asked.said ?? '' });
+    one.known.set(told({ order: 'kind', at: asked.at }), { answered: 'kind', found: 'file' });
+}
+const CHANGES = new Set(['write', 'remove']);
+const within = (at, under) => under === '' || at === under || at.startsWith(under + '/');
+function forgets(one, asked) {
+    if (!CHANGES.has(asked.order)) {
+        one.known.clear();
+        return;
+    }
+    for (const key of [...one.known.keys()]) {
+        const [order = '', at = ''] = JSON.parse(key);
+        if (order === 'real' || within(at, asked.at) || within(asked.at, at))
+            one.known.delete(key);
+    }
 }
 const plainly = (one) => one.order + ' ' + (one.at === '' ? '.' : one.at);
 const outside = (root, at) => {
@@ -299,7 +316,7 @@ function watching(one) {
                 continue;
             }
             if (!READS.has(asked.order))
-                one.known.clear();
+                forgets(one, asked);
             const due = one.replaying.shift();
             if (due !== undefined) {
                 if (told(due.order) === told(asked)) {
@@ -426,31 +443,15 @@ export function running(name, subcommands, at) {
                 ? async (args, shows, within, how) => served(word, args, within, how)
                 : async (args, shows, within, how) => {
                     const where = how?.at ?? at;
-                    const program = programFor(name, where);
+                    const [program = '', ...lead] = programFor(name, where);
                     if ((shows ?? false) !== false)
-                        return handed(where, program, [word, ...args], shows ?? false, within, how?.hears);
-                    return await started(program, [word, ...args], { at: where, ...(within === undefined ? {} : { within }), ...(how?.hears === undefined ? {} : { hears: how.hears }) });
+                        return handed(where, program, [...lead, word, ...args], shows ?? false, within, how?.hears);
+                    return await started(program, [...lead, word, ...args], { at: where, ...(within === undefined ? {} : { within }), ...(how?.hears === undefined ? {} : { hears: how.hears }) });
                 };
     }
     return out;
 }
-function sheet(at) {
-    const path = inTree(findTree(at), 'targets.ts');
-    return existsSync(path) ? valuesIn(readFileSync(path, 'utf8')) : {};
-}
-export function expansions(at) {
-    const held = sheet(at);
-    return (held.TARGETS ?? [])
-        .filter((one) => one.id.startsWith(REACH.cli))
-        .map((one) => ({ program: one.id.slice(REACH.cli.length), target: one, calls: (held.CALLS ?? []).filter((each) => each.of === one.id) }));
-}
-export function calls(target, at) {
-    const named = {};
-    for (const one of sheet(at).CALLS ?? [])
-        if (one.of === target)
-            named[one.id.replace(CALL_PREFIX, '')] = one.path;
-    return running(target.replace(REACH.cli, ''), named, at);
-}
+export { calls, expansions } from '../integrations/declared.js';
 export { LOCKFILES };
 export const manager = (into) => managerOf(into, existsSync);
 const ADDS = { pnpm: 'add', yarn: 'add', bun: 'add', npm: 'install' };
@@ -488,7 +489,8 @@ export function installing(at) {
     if (attached())
         return here().fetch(at);
     const tool = manager(at);
-    const ran = starts(programFor(PACKAGER, at), ['install'], { at });
+    const [program = '', ...lead] = programFor(PACKAGER, at);
+    const ran = starts(program, [...lead, 'install'], { at });
     const said = (ran.out + ran.err).trim();
     if (!ran.there) {
         throw new Error(tool + ' is what the lockfile in ' + at + ' picks, and it is not on this machine, so nothing here can fetch ' +

package/dist/integrations/cli.ts

@@ -8,11 +8,10 @@ import { fileURLToPath } from 'node:url'
 import { CHANNEL, FOLDER, across, attached, createFileSync, existsSync, here, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from '../integrations/disk.ts'
 import { VAULT_DIR } from '../integrations/vault.ts'
 
-import { CALL_PREFIX, LOCKFILES, ORDERS, PACKAGER, REACH, managerOf, programOf, unlisted, type Answer, type Call, type How, type Order, type Ran, type Recorded, type Running, type Target } from '../integrations/target.ts'
+import { LOCKFILES, ORDERS, PACKAGER, REACH, managerOf, programOf, unlisted, type Answer, type How, type Order, type Ran, type Recorded, type Running } from '../integrations/target.ts'
 import { BESIDE, CLI } from '../core/invoked.ts'
-import { valuesIn } from '../core/rows.ts'
 import { THING } from '../core/scope.ts'
-import { findTree, inTree } from '../core/tree.ts'
+import { findTree } from '../core/tree.ts'
 
 export interface Starting {
 
@@ -180,8 +179,8 @@ export function claims(root: string, runs: string): Held {
   return { by: { pid: 0, runs: '', since: Date.now() } }
 }
 
-export function programFor(name: string, at: string): string {
-  const found = programOf(name, at, existsSync)
+export function programFor(name: string, at: string): readonly string[] {
+  const found = programOf(name, at, existsSync, (path) => readFileSync(path, 'utf8'))
   if (found === undefined) throw new Error(unlisted(name))
   return found
 }
@@ -217,6 +216,8 @@ export const PROGRAM = REACH.cli + THING
 
 export const COPIES = THING + ' create copy'
 
+export const COPY_AT = join(VAULT_DIR, THING + '.json')
+
 interface Started {
   readonly words: readonly string[]
   readonly own: string
@@ -244,9 +245,9 @@ function startable(): Started | string {
   } catch {
     return UNCOPIED
   }
-  const copied = ((sheet(root).TARGETS ?? []).find((one) => one.id === PROGRAM)?.derives ?? []).find((one) => one.by === COPIES)?.at
-  if (copied === undefined || !existsSync(resolve(root, copied))) return UNCOPIED
-  const said = readFileSync(resolve(root, copied), 'utf8')
+  const copied = resolve(root, COPY_AT)
+  if (!existsSync(copied)) return UNCOPIED
+  const said = readFileSync(copied, 'utf8')
   const own = join(root, CACHED, createHash('sha256').update(said).digest('hex').slice(0, 16))
   const entry = join(own, 'cli', BESIDE('cli'))
   if (!existsSync(entry)) {
@@ -337,6 +338,24 @@ const READS: ReadonlySet<string> = new Set(Object.entries(ORDERS).filter(([order
 
 function kept(one: Serving, asked: Order, held: Answer): void {
   if (READS.has(asked.order) && held.answered !== 'refused') one.known.set(told(asked), held)
+  if (asked.order !== 'write' || held.answered !== ORDERS.write) return
+  one.known.set(told({ order: 'read', at: asked.at }), { answered: 'read', said: asked.said ?? '' })
+  one.known.set(told({ order: 'kind', at: asked.at }), { answered: 'kind', found: 'file' })
+}
+
+const CHANGES: ReadonlySet<string> = new Set(['write', 'remove'])
+
+const within = (at: string, under: string): boolean => under === '' || at === under || at.startsWith(under + '/')
+
+function forgets(one: Serving, asked: Order): void {
+  if (!CHANGES.has(asked.order)) {
+    one.known.clear()
+    return
+  }
+  for (const key of [...one.known.keys()]) {
+    const [order = '', at = ''] = JSON.parse(key) as readonly string[]
+    if (order === 'real' || within(at, asked.at) || within(asked.at, at)) one.known.delete(key)
+  }
 }
 
 const plainly = (one: Order): string => one.order + ' ' + (one.at === '' ? '.' : one.at)
@@ -390,7 +409,7 @@ function watching(one: Serving): void {
         reply(one.dir, short, known)
         continue
       }
-      if (!READS.has(asked.order)) one.known.clear()
+      if (!READS.has(asked.order)) forgets(one, asked)
       const due = one.replaying.shift()
       if (due !== undefined) {
         if (told(due.order) === told(asked)) {
@@ -513,42 +532,15 @@ export function running(name: string, subcommands: Readonly<Record<string, strin
         ? async (args, shows, within, how) => served(word, args, within, how)
         : async (args, shows, within, how) => {
             const where = how?.at ?? at
-            const program = programFor(name, where)
-            if ((shows ?? false) !== false) return handed(where, program, [word, ...args], shows ?? false, within, how?.hears)
-            return await started(program, [word, ...args], { at: where, ...(within === undefined ? {} : { within }), ...(how?.hears === undefined ? {} : { hears: how.hears }) })
+            const [program = '', ...lead] = programFor(name, where)
+            if ((shows ?? false) !== false) return handed(where, program, [...lead, word, ...args], shows ?? false, within, how?.hears)
+            return await started(program, [...lead, word, ...args], { at: where, ...(within === undefined ? {} : { within }), ...(how?.hears === undefined ? {} : { hears: how.hears }) })
           }
   }
   return out
 }
 
-interface Sheet {
-  readonly TARGETS?: readonly Target[]
-  readonly CALLS?: readonly Call[]
-}
-
-function sheet(at: string): Sheet {
-  const path = inTree(findTree(at), 'targets.ts')
-  return existsSync(path) ? (valuesIn(readFileSync(path, 'utf8')) as Sheet) : {}
-}
-
-export interface Expansion {
-  readonly program: string
-  readonly target: Target
-  readonly calls: readonly Call[]
-}
-
-export function expansions(at: string): readonly Expansion[] {
-  const held = sheet(at)
-  return (held.TARGETS ?? [])
-    .filter((one) => one.id.startsWith(REACH.cli))
-    .map((one) => ({ program: one.id.slice(REACH.cli.length), target: one, calls: (held.CALLS ?? []).filter((each) => each.of === one.id) }))
-}
-
-export function calls(target: string, at: string): Running {
-  const named: Record<string, string> = {}
-  for (const one of sheet(at).CALLS ?? []) if (one.of === target) named[one.id.replace(CALL_PREFIX, '')] = one.path
-  return running(target.replace(REACH.cli, ''), named, at)
-}
+export { calls, expansions, type Expansion } from '../integrations/declared.ts'
 
 export { LOCKFILES }
 
@@ -595,7 +587,8 @@ export function needing(into: string, needs: Readonly<Record<string, string>>):
 export function installing(at: string): string {
   if (attached()) return here().fetch(at)
   const tool = manager(at)
-  const ran = starts(programFor(PACKAGER, at), ['install'], { at })
+  const [program = '', ...lead] = programFor(PACKAGER, at)
+  const ran = starts(program, [...lead, 'install'], { at })
   const said = (ran.out + ran.err).trim()
   if (!ran.there) {
     throw new Error(

package/dist/integrations/declared.d.ts

@@ -0,0 +1,8 @@
+import { type Call, type Running, type Target } from '../integrations/target.ts';
+export interface Expansion {
+    readonly program: string;
+    readonly target: Target;
+    readonly calls: readonly Call[];
+}
+export declare function expansions(at: string): readonly Expansion[];
+export declare function calls(target: string, at: string): Running;

package/dist/integrations/declared.js

@@ -0,0 +1,22 @@
+import { running } from '../integrations/cli.js';
+import { existsSync, readFileSync } from '../integrations/disk.js';
+import { CALL_PREFIX, REACH } from '../integrations/target.js';
+import { valuesIn } from '../core/rows.js';
+import { findTree, inTree } from '../core/tree.js';
+function sheet(at) {
+    const path = inTree(findTree(at), 'targets.ts');
+    return existsSync(path) ? valuesIn(readFileSync(path, 'utf8')) : {};
+}
+export function expansions(at) {
+    const held = sheet(at);
+    return (held.TARGETS ?? [])
+        .filter((one) => one.id.startsWith(REACH.cli))
+        .map((one) => ({ program: one.id.slice(REACH.cli.length), target: one, calls: (held.CALLS ?? []).filter((each) => each.of === one.id) }));
+}
+export function calls(target, at) {
+    const named = {};
+    for (const one of sheet(at).CALLS ?? [])
+        if (one.of === target)
+            named[one.id.replace(CALL_PREFIX, '')] = one.path;
+    return running(target.replace(REACH.cli, ''), named, at);
+}

package/dist/integrations/declared.ts

@@ -0,0 +1,34 @@
+import { running } from '../integrations/cli.ts'
+import { existsSync, readFileSync } from '../integrations/disk.ts'
+import { CALL_PREFIX, REACH, type Call, type Running, type Target } from '../integrations/target.ts'
+import { valuesIn } from '../core/rows.ts'
+import { findTree, inTree } from '../core/tree.ts'
+
+interface Sheet {
+  readonly TARGETS?: readonly Target[]
+  readonly CALLS?: readonly Call[]
+}
+
+function sheet(at: string): Sheet {
+  const path = inTree(findTree(at), 'targets.ts')
+  return existsSync(path) ? (valuesIn(readFileSync(path, 'utf8')) as Sheet) : {}
+}
+
+export interface Expansion {
+  readonly program: string
+  readonly target: Target
+  readonly calls: readonly Call[]
+}
+
+export function expansions(at: string): readonly Expansion[] {
+  const held = sheet(at)
+  return (held.TARGETS ?? [])
+    .filter((one) => one.id.startsWith(REACH.cli))
+    .map((one) => ({ program: one.id.slice(REACH.cli.length), target: one, calls: (held.CALLS ?? []).filter((each) => each.of === one.id) }))
+}
+
+export function calls(target: string, at: string): Running {
+  const named: Record<string, string> = {}
+  for (const one of sheet(at).CALLS ?? []) if (one.of === target) named[one.id.replace(CALL_PREFIX, '')] = one.path
+  return running(target.replace(REACH.cli, ''), named, at)
+}

package/dist/integrations/target.d.ts

@@ -178,7 +178,7 @@ export declare const unreachable: (targets: readonly Target[]) => readonly strin
 export declare const LOCKFILES: Readonly<Record<string, string>>;
 export declare const PACKAGER = "packager";
 export declare const managerOf: (at: string, there: (path: string) => boolean) => string;
-export declare function programOf(name: string, at: string, there: (path: string) => boolean): string | undefined;
+export declare function programOf(name: string, at: string, there: (path: string) => boolean, read: (path: string) => string): readonly string[] | undefined;
 export declare const unlisted: (name: string) => string;
 export declare function misnamed(target: string, name: string): string | undefined;
 export declare function misaccepted(targets: readonly Target[], entities: readonly string[], calls: readonly Call[]): readonly string[];

package/dist/integrations/target.js

@@ -143,17 +143,31 @@ export const PACKAGER = 'packager';
 const NAMED = ['git', 'thread'];
 const RUNTIME = 'node';
 export const managerOf = (at, there) => Object.entries(LOCKFILES).find(([lock]) => there(join(at, lock)))?.[1] ?? 'npm';
-export function programOf(name, at, there) {
+export function programOf(name, at, there, read) {
     if (NAMED.includes(name))
-        return name;
+        return [name];
     if (name === RUNTIME)
-        return execPath;
+        return [execPath];
     if (name === PACKAGER)
-        return managerOf(at, there);
+        return [managerOf(at, there)];
     const installed = join(at, 'node_modules', '.bin', name);
-    return there(installed) ? installed : undefined;
+    if (there(installed))
+        return [installed];
+    const shipped = join(at, 'node_modules', name);
+    const manifest = join(shipped, 'package.json');
+    if (!there(manifest))
+        return undefined;
+    let bin;
+    try {
+        bin = JSON.parse(read(manifest)).bin;
+    }
+    catch {
+        return undefined;
+    }
+    const entry = typeof bin === 'string' ? bin : typeof bin === 'object' && bin !== null ? bin[name] : undefined;
+    return typeof entry === 'string' ? [execPath, join(shipped, entry)] : undefined;
 }
-export const unlisted = (name) => '`' + REACH.cli + name + '` names ' + name + ', and nothing lists a program by that name: it is not under node_modules/.bin, so this tree did not install it; it is not git, node or thread; and it is not `' + PACKAGER + '`, the word for whichever package manager the lockfile picks. A program the tree did not install is whatever the machine happens to have, and a target on that is a shell by another name. Add the package that provides it and declare the target again, or ask for it through a declared call on `' + REACH.cli + PACKAGER + '`';
+export const unlisted = (name) => '`' + REACH.cli + name + '` names ' + name + ', and nothing lists a program by that name: it is not linked under node_modules/.bin, and no package installed here under that name names it as its program, so this tree did not install it; it is not git, node or thread; and it is not `' + PACKAGER + '`, the word for whichever package manager the lockfile picks. A program the tree did not install is whatever the machine happens to have, and a target on that is a shell by another name. Add the package that provides it and declare the target again, or ask for it through a declared call on `' + REACH.cli + PACKAGER + '`';
 const SHAPED = {
     cli: /^-{0,2}[A-Za-z][A-Za-z0-9-]*$/,
 };

package/dist/integrations/target.ts

@@ -412,16 +412,32 @@ const RUNTIME = 'node'
 export const managerOf = (at: string, there: (path: string) => boolean): string =>
   Object.entries(LOCKFILES).find(([lock]) => there(join(at, lock)))?.[1] ?? 'npm'
 
-export function programOf(name: string, at: string, there: (path: string) => boolean): string | undefined {
-  if (NAMED.includes(name)) return name
-  if (name === RUNTIME) return execPath
-  if (name === PACKAGER) return managerOf(at, there)
+export function programOf(
+  name: string,
+  at: string,
+  there: (path: string) => boolean,
+  read: (path: string) => string,
+): readonly string[] | undefined {
+  if (NAMED.includes(name)) return [name]
+  if (name === RUNTIME) return [execPath]
+  if (name === PACKAGER) return [managerOf(at, there)]
   const installed = join(at, 'node_modules', '.bin', name)
-  return there(installed) ? installed : undefined
+  if (there(installed)) return [installed]
+  const shipped = join(at, 'node_modules', name)
+  const manifest = join(shipped, 'package.json')
+  if (!there(manifest)) return undefined
+  let bin: unknown
+  try {
+    bin = (JSON.parse(read(manifest)) as { readonly bin?: unknown }).bin
+  } catch {
+    return undefined
+  }
+  const entry = typeof bin === 'string' ? bin : typeof bin === 'object' && bin !== null ? (bin as Readonly<Record<string, unknown>>)[name] : undefined
+  return typeof entry === 'string' ? [execPath, join(shipped, entry)] : undefined
 }
 
 export const unlisted = (name: string): string =>
-  '`' + REACH.cli + name + '` names ' + name + ', and nothing lists a program by that name: it is not under node_modules/.bin, so this tree did not install it; it is not git, node or thread; and it is not `' + PACKAGER + '`, the word for whichever package manager the lockfile picks. A program the tree did not install is whatever the machine happens to have, and a target on that is a shell by another name. Add the package that provides it and declare the target again, or ask for it through a declared call on `' + REACH.cli + PACKAGER + '`'
+  '`' + REACH.cli + name + '` names ' + name + ', and nothing lists a program by that name: it is not linked under node_modules/.bin, and no package installed here under that name names it as its program, so this tree did not install it; it is not git, node or thread; and it is not `' + PACKAGER + '`, the word for whichever package manager the lockfile picks. A program the tree did not install is whatever the machine happens to have, and a target on that is a shell by another name. Add the package that provides it and declare the target again, or ask for it through a declared call on `' + REACH.cli + PACKAGER + '`'
 
 const SHAPED: Readonly<Record<'cli', RegExp>> = {
   cli: /^-{0,2}[A-Za-z][A-Za-z0-9-]*$/,

package/dist/integrity/generators/publish.js

@@ -1,4 +1,5 @@
-import { calls, starts } from '../../integrations/cli.js';
+import { starts } from '../../integrations/cli.js';
+import { calls } from '../../integrations/declared.js';
 import { existsSync, readFileSync } from '../../integrations/disk.js';
 import { valuesIn } from '../../core/rows.js';
 import { join } from 'node:path';

package/dist/integrity/generators/publish.ts

@@ -1,4 +1,5 @@
-import { calls, starts } from '../../integrations/cli.ts'
+import { starts } from '../../integrations/cli.ts'
+import { calls } from '../../integrations/declared.ts'
 import { existsSync, readFileSync } from '../../integrations/disk.ts'
 import { valuesIn } from '../../core/rows.ts'
 import { join } from 'node:path'

package/dist/integrity/slopnators/sl_unlisted_program.js

@@ -1,6 +1,6 @@
 import { ROOT } from '../../core/descend.js';
 import { valuesIn } from '../../core/rows.js';
-import { kind } from '../../integrations/disk.js';
+import { kind, readFileSync } from '../../integrations/disk.js';
 import { REACH, programOf, unlisted } from '../../integrations/target.js';
 const TARGETS = 'TARGETS';
 const there = (path) => kind(path) === 'file';
@@ -20,7 +20,7 @@ export const slopnator = {
             if (typeof one.id !== 'string' || !one.id.startsWith(REACH.cli))
                 continue;
             const name = one.id.slice(REACH.cli.length);
-            if (programOf(name, ROOT, there) === undefined)
+            if (programOf(name, ROOT, there, (path) => readFileSync(path, 'utf8')) === undefined)
                 found.push(unlisted(name));
         }
         return found.length === 0 ? false : found.join('. ');

package/dist/integrity/slopnators/sl_unlisted_program.ts

@@ -1,6 +1,6 @@
 import { ROOT } from '../../core/descend.ts'
 import { valuesIn } from '../../core/rows.ts'
-import { kind } from '../../integrations/disk.ts'
+import { kind, readFileSync } from '../../integrations/disk.ts'
 import { REACH, programOf, unlisted } from '../../integrations/target.ts'
 
 import type { Slopnator } from '../slopnator.ts'
@@ -22,7 +22,7 @@ export const slopnator: Slopnator = {
     for (const one of held.TARGETS ?? []) {
       if (typeof one.id !== 'string' || !one.id.startsWith(REACH.cli)) continue
       const name = one.id.slice(REACH.cli.length)
-      if (programOf(name, ROOT, there) === undefined) found.push(unlisted(name))
+      if (programOf(name, ROOT, there, (path) => readFileSync(path, 'utf8')) === undefined) found.push(unlisted(name))
     }
     return found.length === 0 ? false : found.join('. ')
   },

package/dist/operations/generators/compile.d.ts

@@ -1,2 +1,23 @@
+import { type Call, type Target } from '../../integrations/target.ts';
+import type { Secret } from '../../integrations/secret.ts';
+export declare function reached(targets: readonly Target[], calls: readonly Call[], secrets: readonly Secret[]): Readonly<Record<string, {
+    readonly reach: string;
+    readonly address?: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly sends: readonly {
+        readonly secret: string;
+        readonly header: string;
+        readonly prefix: string;
+    }[];
+    readonly signs: readonly {
+        readonly secret: string;
+        readonly header: string;
+        readonly prefix: string;
+    }[];
+    readonly calls: Readonly<Record<string, {
+        readonly method: string | null;
+        readonly path: string;
+    }>>;
+}>>;
 export declare function parts(text: string): readonly string[];
 export declare function compile(say?: boolean): Promise<number>;

package/dist/operations/generators/compile.js

@@ -27,7 +27,7 @@ async function reaching() {
     const secrets = await held('secrets.ts', 'SECRETS');
     return reached(targets, calls, secrets);
 }
-function reached(targets, calls, secrets) {
+export function reached(targets, calls, secrets) {
     const out = {};
     for (const one of targets) {
         const mine = calls.filter((each) => each.of === one.id && one.takes.includes(each.id));

package/dist/operations/generators/compile.ts

@@ -32,7 +32,7 @@ async function reaching(): Promise<Readonly<Record<string, ReturnType<typeof rea
   return reached(targets, calls, secrets)
 }
 
-function reached(
+export function reached(
   targets: readonly Target[],
   calls: readonly Call[],
   secrets: readonly Secret[],

package/dist/operations/generators/permits.d.ts

@@ -1 +1,2 @@
-export {};
+import { type Grant } from '../access.ts';
+export declare function permitting(grants: readonly Grant[]): string;