@prestack/thread 0.1.3 → 0.1.5

package/dist/core/actor.d.ts

@@ -1,5 +1,5 @@
 export type Env = 'sandbox' | 'production';
-export declare const ENVIRONMENT: readonly [readonly ["run", "x-request-id"], readonly ["address", "x-forwarded-for"], readonly ["device", "user-agent"], readonly ["replay", "idempotency-key"]];
+export declare const ENVIRONMENT: readonly [readonly ['run', 'x-request-id', 'crypto.randomUUID()'], readonly ['address', 'x-forwarded-for', null], readonly ['device', 'user-agent', null], readonly ['replay', 'idempotency-key', null], readonly ['moment', null, 'new Date().toISOString()']];
 export type Environment = {
     readonly [K in (typeof ENVIRONMENT)[number][0]]?: string;
 };

package/dist/core/actor.js

@@ -1,8 +1,9 @@
 export const ENVIRONMENT = [
-    ['run', 'x-request-id'],
-    ['address', 'x-forwarded-for'],
-    ['device', 'user-agent'],
-    ['replay', 'idempotency-key'],
+    ['run', 'x-request-id', 'crypto.randomUUID()'],
+    ['address', 'x-forwarded-for', null],
+    ['device', 'user-agent', null],
+    ['replay', 'idempotency-key', null],
+    ['moment', null, 'new Date().toISOString()'],
 ];
 export const PUBLIC_ROLE = 'role_public';
 export const ANONYMOUS = { id: null, roles: [PUBLIC_ROLE], entitlements: [] };

package/dist/core/actor.ts

@@ -1,10 +1,11 @@
 export type Env = 'sandbox' | 'production'
 
 export const ENVIRONMENT = [
-  ['run', 'x-request-id'],
-  ['address', 'x-forwarded-for'],
-  ['device', 'user-agent'],
-  ['replay', 'idempotency-key'],
+  ['run', 'x-request-id', 'crypto.randomUUID()'],
+  ['address', 'x-forwarded-for', null],
+  ['device', 'user-agent', null],
+  ['replay', 'idempotency-key', null],
+  ['moment', null, 'new Date().toISOString()'],
 ] as const
 
 export type Environment = { readonly [K in (typeof ENVIRONMENT)[number][0]]?: string }

package/dist/core/attach.d.ts

@@ -14,13 +14,6 @@ export interface Attaching {
     readonly writes: readonly Writing[];
     readonly declares: string;
     readonly rows?: readonly Appending[];
-    readonly retires?: readonly {
-        readonly into: string;
-        readonly list: string;
-        readonly id: string;
-        readonly made?: string;
-        readonly why: string;
-    }[];
     readonly attaches?: readonly string[];
     readonly scripts?: Readonly<Record<string, string>>;
     readonly needs?: Readonly<Record<string, string>>;

package/dist/core/attach.js

@@ -6,14 +6,16 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, fetching, readFileSync, rmSync, writeFileSync } from "./files.js";
+import { installing, needing } from '../integrations/cli.js';
+import { attached, existsSync, readFileSync, rmSync, writeFileSync } from '../integrations/disk.js';
 import { createRequire } from 'node:module';
 import { join, relative, resolve } from 'node:path';
 import { stdout } from 'node:process';
-import { LISTS } from "./descend.js";
-import { ROOT, TREE, root as rooted } from "./init.js";
-import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from "./rows.js";
-import { ours as isOurs } from "./scope.js";
+import { LISTS } from './descend.js';
+import { ROOT, SHAPED, TREE, root as rooted } from './init.js';
+import { BESIDE } from './invoked.js';
+import { STATED, holdsRow, listBounds, quoted, reconciled, rowsIn, withRow, withoutRow } from './rows.js';
+import { idOf, installed, ours as isOurs } from './scope.js';
 const SHAPE = /export interface [A-Za-z0-9_]+ extends Threaded \{[\s\S]*?\n\}\n/;
 const MEMBERS = 'MEMBERS';
 const DOOR = '/attach';
@@ -64,12 +66,21 @@ export async function attaches(into, name) {
         return false;
     }
 }
+function shipped(spec, owner) {
+    const rest = spec.slice(owner.length + 1);
+    const named = idOf(owner) ?? owner;
+    const part = rest === DOOR.slice(1) ? named : String(rest.split('/')[0]);
+    return new URL('../' + part + '/' + BESIDE('attach'), import.meta.url).href;
+}
 async function attaching(into, name) {
     const spec = name.endsWith(DOOR) ? name : `${name}${DOOR}`;
     const owner = packageOf(name);
     let held;
     try {
-        held = (await import(__rewriteRelativeImportExtension(createRequire(join(into, 'package.json')).resolve(spec))));
+        if (attached() && isOurs(owner))
+            held = (await import(__rewriteRelativeImportExtension(shipped(spec, owner))));
+        else
+            held = (await import(__rewriteRelativeImportExtension(createRequire(join(into, 'package.json')).resolve(spec))));
     }
     catch {
         if (!existsSync(join(into, 'node_modules', owner, 'package.json'))) {
@@ -123,7 +134,7 @@ function acquire(into, owner) {
     stdout.write(`thread: ${owner} is not here yet, so this is fetching it. Nothing has to be typed for that.\n`);
     writeFileSync(manifest, `${JSON.stringify({ ...parsed, dependencies: { ...parsed.dependencies, [owner]: 'latest' } }, null, 2)}\n`, 'utf8');
     try {
-        fetching(into);
+        installing(into);
     }
     catch (thrown) {
         writeFileSync(manifest, was, 'utf8');
@@ -160,7 +171,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
         await attach(into, on, touched, [...under, name]);
     }
     const plan = new Map();
-    const retired = [];
     const reshaped = [];
     const noticed = [];
     const held = readFileSync(root, 'utf8');
@@ -168,7 +178,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
     const ours = [...one.declares.matchAll(/\bid: '([^']+)'/g)].map((found) => found[1]);
     const mine = declares !== undefined &&
         (holdsRow(held, declares, one.id) || ours.some((id) => id !== undefined && holdsRow(held, declares, id)));
-    const installed = (at) => at.startsWith('node_modules/') && isOurs(at.split('/').slice(1, 3).join('/'));
     const pathIn = (source) => {
         const listed = `const HELD = {\n  declares: [\n${source}\n  ],\n}\n`;
         const span = listBounds(listed, 'declares');
@@ -305,14 +314,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
                     return false;
                 return !text.slice(where.open, where.close).includes(each.source.trim().replace(/,$/, ''));
             }).length;
-            const withdrawing = (one.retires ?? []).filter((gone) => {
-                const at = join(dir, gone.into);
-                if (!existsSync(at))
-                    return false;
-                const text = plan.get(at) ?? readFileSync(at, 'utf8');
-                const where = listBounds(text, gone.list);
-                return where !== undefined && holdsRow(text, where, gone.id);
-            }).length;
             throw new Error(`${name} brings a noun called \`${coined}\`, and this tree already declares something by that name. One ` +
                 `word, one meaning: if this attached, \`thread create ${coined}\` would run the package's command and the ` +
                 `thing you declared would be reachable only by its mark.\n\n` +
@@ -321,11 +322,10 @@ export async function attach(into, name, touched = new Set(), under = []) {
                 `Nothing was written.\n\n` +
                 `A refusal here names a command you can actually run. If the one above does not fit what you are trying ` +
                 `to do, that is a gap in this framework rather than something to work around — say so.` +
-                (waiting + withdrawing === 0
+                (waiting === 0
                     ? ''
                     : `\n\nAn attach is all or nothing, so this is also holding back everything else ${name} would have ` +
-                        `delivered: ${String(waiting)} row(s) this tree does not hold at the version installed` +
-                        `${withdrawing === 0 ? '' : ` and ${String(withdrawing)} it has withdrawn`}. None of that arrives until the ` +
+                        `delivered: ${String(waiting)} row(s) this tree does not hold at the version installed. None of that arrives until the ` +
                         `collision above is cleared, and nothing else will tell you — \`npm install\` will go on reporting this ` +
                         `tree current.`));
         }
@@ -347,28 +347,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
             throw new UnattachableError(name, `wants a row in \`${row.list}\`, which ${row.into} does not export`);
         plan.set(target, withRow(held, bounds, row.source));
     }
-    for (const gone of one.retires ?? []) {
-        const shipped = (one.rows ?? []).find((row) => row.into === gone.into && row.list === gone.list && row.id === gone.id);
-        if (shipped !== undefined) {
-            throw new UnattachableError(name, `both ships and retires \`${gone.id}\` in ${gone.into}, so attaching it would add and remove one row`);
-        }
-        if (gone.made !== undefined) {
-            const byproduct = join(into, gone.made);
-            if (existsSync(byproduct)) {
-                rmSync(byproduct);
-                retired.push(`${gone.made} — the file \`${gone.id}\` derived, which nothing writes now`);
-            }
-        }
-        const target = join(dir, gone.into);
-        if (!existsSync(target) && !plan.has(target))
-            continue;
-        const text = plan.get(target) ?? readFileSync(target, 'utf8');
-        const where = listBounds(text, gone.list);
-        if (where === undefined || !holdsRow(text, where, gone.id))
-            continue;
-        plan.set(target, withoutRow(text, where, gone.id));
-        retired.push(`${gone.into}: ${gone.id} — ${gone.why}`);
-    }
     if (one.scripts !== undefined) {
         const manifest = join(into, 'package.json');
         const held = readFileSync(manifest, 'utf8');
@@ -386,29 +364,24 @@ export async function attach(into, name, touched = new Set(), under = []) {
     }
     if (one.needs !== undefined) {
         const manifest = join(into, 'package.json');
-        const held = plan.get(manifest) ?? readFileSync(manifest, 'utf8');
-        const parsed = JSON.parse(held);
-        const needs = { ...parsed.dependencies };
-        const added = [];
-        for (const [name, at] of Object.entries(one.needs)) {
-            if (needs[name] !== undefined)
-                continue;
-            needs[name] = at;
-            added.push(name);
+        const was = readFileSync(manifest, 'utf8');
+        const scripted = plan.get(manifest);
+        if (scripted !== undefined) {
+            writeFileSync(manifest, scripted, 'utf8');
+            plan.delete(manifest);
+            touched.add(relative(into, manifest));
+        }
+        let added;
+        try {
+            added = needing(into, one.needs);
+        }
+        catch (thrown) {
+            writeFileSync(manifest, was, 'utf8');
+            throw new Error(`${thrown instanceof Error ? thrown.message : String(thrown)} Nothing was attached.`);
         }
         if (added.length > 0) {
-            const next = `${JSON.stringify({ ...parsed, dependencies: needs }, null, 2)}\n`;
-            const was = readFileSync(manifest, 'utf8');
-            writeFileSync(manifest, next, 'utf8');
             touched.add(relative(into, manifest));
-            stdout.write(`thread: ${name} needs ${added.join(', ')}, so this is fetching ${added.length === 1 ? 'it' : 'them'}. Nothing has to be typed for that.\n`);
-            try {
-                fetching(into);
-            }
-            catch (thrown) {
-                writeFileSync(manifest, was, 'utf8');
-                throw new Error(`${added.join(', ')} could not be fetched — ${thrown instanceof Error ? thrown.message : String(thrown)} Nothing was attached and package.json is as it was.`);
-            }
+            stdout.write(`thread: ${name} needs ${added.join(', ')}, so ${added.length === 1 ? 'it is' : 'they are'} in package.json now and fetched. Nothing has to be typed for that.\n`);
         }
     }
     if (one.ignores !== undefined && one.ignores.length > 0) {
@@ -425,8 +398,6 @@ export async function attach(into, name, touched = new Set(), under = []) {
         writeFileSync(path, text, 'utf8');
         touched.add(relative(into, path));
     }
-    for (const line of retired)
-        stdout.write(`thread: retired ${line}\n`);
     for (const file of reshaped)
         stdout.write(`thread: reshaped ${file} — what a row may state has changed\n`);
     for (const id of noticed)
@@ -512,8 +483,8 @@ export async function detach(into, name) {
     }
     return [...touched].sort();
 }
-const DESCRIBES = 'The package every tree installs first: the descent, the CLI, and the makers and generators that used to be separate packages.';
-const CORE_SOURCE = `import type { Threaded } from '../core/thread.ts'
+const DESCRIBES = 'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.';
+const CORE_SOURCE = `import type { Threaded } from '${SHAPED}'
 
 export const CORE: Threaded = {
   id: 'core',
@@ -532,7 +503,7 @@ const SEEDED = {
         '    {',
         '      id: \'core\',',
         '      at: \'_threads/core.ts\',',
-        '      describes: \'The package every tree installs first: the descent, the CLI, and the makers and generators that used to be separate packages.\',',
+        '      describes: \'The package every tree installs first: the descent that reads a tree, the gate that checks it, and the generators every tree runs.\',',
         '      version: 1,',
         '    },',
     ].join('\n'),

package/dist/core/attach.ts

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

package/dist/core/chain.js

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

package/dist/core/chain.ts

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

package/dist/core/condition.d.ts

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

package/dist/core/condition.js

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