@prestack/thread 0.1.20 → 0.1.22

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;
@@ -246,6 +245,63 @@ 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 AHEAD = 32;
+const upOf = (at) => (at.includes('/') ? at.slice(0, at.lastIndexOf('/')) : '');
+const nameOf = (at) => at.slice(at.lastIndexOf('/') + 1);
+const inside = (at, name) => (at === '' ? name : at + '/' + name);
+function listedAt(one, at) {
+    const held = one.known.get(told({ order: 'list', at }))?.found;
+    return Array.isArray(held) ? held : [];
+}
+function realOf(one, at) {
+    const held = one.known.get(told({ order: 'real', at }));
+    if (held !== undefined || at === '')
+        return held;
+    const entry = listedAt(one, upOf(at)).find((each) => each.name === nameOf(at));
+    if (entry === undefined || entry.kind === 'other')
+        return undefined;
+    const above = realOf(one, upOf(at));
+    return typeof above?.at === 'string' ? { answered: 'real', at: above.at + '/' + nameOf(at) } : undefined;
+}
+function aheadOf(one, asked) {
+    if (asked.order === 'real')
+        return asked.at === '' || one.known.has(told({ order: 'real', at: '' })) ? [] : [{ order: 'real', at: '', ahead: true }];
+    const name = nameOf(asked.at);
+    const dot = name.indexOf('.');
+    const reading = asked.order === 'read' && dot > 0 && asked.at.split('/').includes(INSTALLED);
+    if (!reading && asked.order !== 'stat')
+        return [];
+    const suffix = reading ? name.slice(dot) : '';
+    const up = upOf(asked.at);
+    const found = [];
+    for (const each of listedAt(one, up)) {
+        if (found.length === AHEAD)
+            break;
+        if (each.kind !== 'file' || each.name === name || !each.name.endsWith(suffix))
+            continue;
+        const order = { order: asked.order, at: inside(up, each.name), ahead: true };
+        if (!one.known.has(told(order)))
+            found.push(order);
+    }
+    return found;
 }
 const plainly = (one) => one.order + ' ' + (one.at === '' ? '.' : one.at);
 const outside = (root, at) => {
@@ -299,11 +355,22 @@ function watching(one) {
                 reply(one.dir, short, known);
                 continue;
             }
+            const derived = asked.order === 'real' ? realOf(one, asked.at) : undefined;
+            if (derived !== undefined) {
+                reply(one.dir, short, derived);
+                kept(one, asked, derived);
+                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)) {
+                    while (one.replaying[0]?.order.ahead === true) {
+                        const extra = one.replaying.shift();
+                        if (extra !== undefined)
+                            kept(one, extra.order, extra.answered);
+                    }
                     reply(one.dir, short, due.answered);
                     kept(one, asked, due.answered);
                     continue;
@@ -318,7 +385,8 @@ function watching(one) {
             }
             one.pending = short;
             one.asking = asked;
-            hand(one, still(one, [asked]));
+            one.ahead = aheadOf(one, asked);
+            hand(one, still(one, [asked, ...one.ahead]));
         }
     }, TICK);
 }
@@ -346,11 +414,11 @@ function next(one, within) {
         }, Math.max(1_000, within - MARGIN));
     });
 }
-function begun(from, word, args, root, hears, called, recording = []) {
+function begun(from, word, args, root, hears, called, recording = [], stash) {
     const of = called ?? randomBytes(6).toString('hex');
     const dir = join(tmpdir(), SERVED, randomBytes(6).toString('hex'));
     writeFileSync(join(dir, 'channel'), '', 'utf8');
-    const one = { of, dir, root, out: '', err: '', why: '', pending: '', waiting: [], parked: [], replaying: [...recording], handed: recording.length, known: new Map() };
+    const one = { of, dir, root, out: '', err: '', why: '', pending: '', waiting: [], parked: [], replaying: [...recording], handed: recording.length, known: new Map(), ahead: [], ...(stash === undefined ? {} : { stash }) };
     const child = spawn(execPath, [...from.words, word, ...args], {
         cwd: from.own,
         shell: false,
@@ -381,6 +449,7 @@ function counted(one, held) {
     one.last = held;
     return held;
 }
+const stashing = (one, held) => (one.stash === undefined ? held : { ...held, stashed: one.stash });
 async function served(word, args, within, how) {
     const of = how?.of;
     if (of !== undefined) {
@@ -395,20 +464,26 @@ async function served(word, args, within, how) {
             const from = startable();
             if (typeof from === 'string')
                 return nowhere(from);
-            const again = begun(from, word, args, root, how?.hears, of, recording);
-            return counted(again, await next(again, within));
+            const again = begun(from, word, args, root, how?.hears, of, recording, how?.stash);
+            return stashing(again, counted(again, await next(again, within)));
         }
         const answering = how?.answering;
         if (answering !== undefined && answering < one.handed && one.last !== undefined)
-            return one.last;
-        const given = (how?.answered ?? [])[0];
+            return stashing(one, one.last);
+        const [given, ...rest] = how?.answered ?? [];
         if (one.pending !== '' && given !== undefined) {
+            one.ahead.forEach((order, index) => {
+                const held = rest[index];
+                if (held !== undefined)
+                    kept(one, order, held);
+            });
+            one.ahead = [];
             reply(one.dir, one.pending, given);
             if (one.asking !== undefined)
                 kept(one, one.asking, given);
             one.pending = '';
         }
-        return counted(one, await next(one, within));
+        return stashing(one, counted(one, await next(one, within)));
     }
     const root = how?.at ?? '';
     if (root === '')
@@ -416,8 +491,8 @@ async function served(word, args, within, how) {
     const from = startable();
     if (typeof from === 'string')
         return nowhere(from);
-    const fresh = begun(from, word, args, root, how?.hears);
-    return counted(fresh, await next(fresh, within));
+    const fresh = begun(from, word, args, root, how?.hears, undefined, [], how?.stash);
+    return stashing(fresh, counted(fresh, await next(fresh, within)));
 }
 export function running(name, subcommands, at) {
     const out = {};
@@ -427,31 +502,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' };
@@ -489,7 +548,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/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/pglite.js

@@ -52,14 +52,24 @@ export async function shapeOf(sql) {
     }
 }
 export function standing(held) {
-    const store = storing({ ...held, at: 'memory://', migrations: [] });
+    const store = storing({ ...held, at: 'memory://' });
     const keeps = Object.keys(held.tables);
     return {
         keeps,
         store,
         async seed(actor, rows) {
-            for (const one of rows)
+            for (const one of rows) {
+                const by = held.address[one.entity];
+                const key = by === undefined ? undefined : one.row[by];
+                if (by !== undefined && (typeof key === 'string' || typeof key === 'number')) {
+                    const there = await store.list(actor, one.entity, { where: { [by]: key }, limit: 1 });
+                    if (there.length > 0) {
+                        await store.update(actor, one.entity, key, one.row);
+                        continue;
+                    }
+                }
                 await store.insert(actor, one.entity, one.row);
+            }
         },
         async taken(actor) {
             const found = {};
@@ -83,7 +93,7 @@ export function storing(held) {
         const found = held.address[entity];
         if (found === undefined) {
             throw new Error(entity + ' declares nothing that identifies one of its rows, so a row of it cannot be addressed here. ' +
-                'Give it a value and say so with `thread create entity edit`.');
+                'Name the value that does: give `thread edit ' + entity + ' --must` its invariants again with one more, unique over that value alone.');
         }
         return found;
     };

package/dist/integrations/target.d.ts

@@ -68,6 +68,7 @@ export interface Order {
     readonly said?: string;
     readonly mode?: number;
     readonly words?: readonly string[];
+    readonly ahead?: boolean;
 }
 export interface Answer {
     readonly answered: string;
@@ -87,6 +88,7 @@ export interface How {
     readonly answered?: readonly Answer[];
     readonly recording?: readonly Recorded[];
     readonly answering?: number;
+    readonly stash?: unknown;
 }
 export interface Ran {
     readonly there: boolean;
@@ -99,6 +101,7 @@ export interface Ran {
     readonly of?: string;
     readonly asks?: readonly Order[];
     readonly lost?: string;
+    readonly stashed?: unknown;
 }
 export type Running<C extends string = string> = Readonly<Record<C, (args: readonly string[], shows?: boolean | 'errors' | 'tee', within?: number, how?: How) => Promise<Ran>>>;
 export type Calling<C extends string = string> = {
@@ -178,7 +181,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/integrity/attach.js

@@ -116,11 +116,7 @@ export const ATTACH = {
         { file: 'rules.ts', source: RULES_SOURCE },
         { file: 'gate.ts', source: GATE_SOURCE },
     ],
-    ignores: ['.thread/', '.next/', 'node_modules/', 'tsconfig.tsbuildinfo'],
-    scripts: {
-        build: 'next build',
-        start: 'next start',
-    },
+    ignores: ['.thread/', 'node_modules/', 'tsconfig.tsbuildinfo'],
     needs: {
         '@types/node': '^24.0.0',
         typescript: '^6.0.0',

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/slopnators/sl_stale_path.js

@@ -76,6 +76,9 @@ export const slopnator = {
             return false;
         if (derived().has(path))
             return false;
+        const folder = path.slice(0, path.lastIndexOf('/'));
+        if (statSync(resolve(ROOT, folder), { throwIfNoEntry: false })?.isDirectory() !== true)
+            return false;
         return `\`${value}\` is not on disk`;
     },
     proves: {
@@ -152,6 +155,13 @@ export const slopnator = {
                 ],
                 at: 'probe.tsx',
             },
+            {
+                files: [
+                    { at: 'docs/_probe_there.md', source: 'there\n' },
+                    { at: 'probe.tsx', source: "const at = 'docs/elsewhere/entry.ts'\n" },
+                ],
+                at: 'probe.tsx',
+            },
             "const at = 'threads/'",
             "const said = 'a sentence about packages/core/integrity/src/constraint.ts and nothing else'",
             {

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/operations/access.js

@@ -17,8 +17,9 @@ export function undeclared(answered, offers, which) {
     return (`this app declares no ${which === 'roles' ? 'role' : 'entitlement'} called ${stray.map((one) => `\`${one}\``).join(', ')} — ` +
         (offers.length === 0
             ? `it declares none at all. A ${which === 'roles' ? 'role' : 'entitlement'} is one of the words the value an ` +
-                'entity names as saying what a caller may do is held to. Declare them with `thread create entity edit` — ' +
-                'name that value, give it the `choice` format, and state its options'
+                'entity names as saying what a caller may do is held to. Declare them on that entity: give ' +
+                '`thread edit <entity> --holds` its values again with that one in the `choice` format and its options stated, ' +
+                `and name it as \`${which}\` in \`thread edit <entity> --actor\``
             : `it declares ${offers.map((one) => `\`${one}\``).join(', ')}`));
 }
 export const keyIn = (one) => (one.must ?? []).flatMap((each) => (each.unique?.length === 1 ? [each.unique[0]] : []))[0];

package/dist/operations/capabilities.d.ts

@@ -9,6 +9,8 @@ export interface Defaults extends Threaded {
     readonly live?: readonly Surface[];
 }
 export declare const CAPABILITIES_AT = "operations/_capabilities.json";
+export declare const SERVER_AT = "_generated/server/entry.ts";
+export declare const SERVER_OUT = "_generated/server/server.mjs";
 export declare const CLIENT_AT = "operations/_client.ts";
 export declare const DISPATCHING_AT = "app/_generated/dispatching.ts";
 export declare const COMPILED = "app/_generated/compiled";

package/dist/operations/capabilities.js

@@ -9,6 +9,8 @@ export const MEANS = {
 export const DEFAULTS_AT = '_threads/defaults.ts';
 export const UNSTATED = ['cli'];
 export const CAPABILITIES_AT = 'operations/_capabilities.json';
+export const SERVER_AT = '_generated/server/entry.ts';
+export const SERVER_OUT = '_generated/server/server.mjs';
 export const CLIENT_AT = 'operations/_client.ts';
 export const DISPATCHING_AT = 'app/_generated/dispatching.ts';
 export const COMPILED = 'app/_generated/compiled';