@prestack/thread 0.0.1

package/dist/core/chain.js

@@ -0,0 +1,114 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execPath } from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { findTree } from "./tree.js";
+const STATING = 'derivation.ts';
+export async function generators(tree = findTree()) {
+    if (!existsSync(tree.dir))
+        return [];
+    const sheets = readdirSync(tree.dir)
+        .filter((one) => one.endsWith('.ts'))
+        .sort((one, two) => (one === STATING ? -1 : two === STATING ? 1 : one < two ? -1 : one > two ? 1 : 0));
+    const found = [];
+    for (const name of sheets) {
+        const sheet = join(tree.dir, name);
+        try {
+            const held = (await import(__rewriteRelativeImportExtension(pathToFileURL(sheet).href)));
+            found.push(...(held.GENERATORS ?? []));
+        }
+        catch (thrown) {
+            throw new Error(`${sheet} is one of the sheets where this tree states the commands it offers, and reading it threw: ` +
+                `${thrown instanceof Error ? thrown.message : String(thrown)}. A tree whose generators cannot be read ` +
+                'offers exactly what a tree declaring none offers, so everything derived from your declarations would be ' +
+                'left stale by a command reporting that it had finished. Fix that file.');
+        }
+    }
+    return found;
+}
+export const offers = (all) => new Set(all.map((one) => (typeof one.by === 'string' ? one.by : '')).filter((one) => one !== ''));
+const ROUNDS = 4;
+const word = (held) => (typeof held === 'string' ? held.trim() : '');
+const FROM_SOURCE = import.meta.url.endsWith('.ts');
+const RUNNER = fileURLToPath(new URL(FROM_SOURCE ? './round.ts' : './round.js', import.meta.url));
+const LOADER = FROM_SOURCE ? ['--import', 'tsx'] : [];
+export const RAN = 'round: ran';
+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 found = new Map();
+    let held = [];
+    for (const line of lines) {
+        const mark = line.startsWith(RAN) ? RAN : line.startsWith(REFUSED_BY) ? REFUSED_BY : undefined;
+        if (mark === undefined) {
+            held.push(line);
+            continue;
+        }
+        const command = line.slice(mark.length).trim();
+        found.set(command, { command, ok: mark === RAN, said: held.join('\n').trim() });
+        held = [];
+    }
+    const orphaned = held.join('\n').trim();
+    let firstUnreached = true;
+    return commands.map((one) => {
+        const has = found.get(one);
+        if (has !== undefined)
+            return has;
+        const why = `settle: the runner never reported on \`${one}\`, so it was not run and is not settled.`;
+        const said = firstUnreached && orphaned !== '' ? `${orphaned}\n${why}` : why;
+        firstUnreached = false;
+        return { command: one, ok: false, said };
+    });
+}
+const WITHIN = 300_000;
+function batch(at, commands) {
+    const all = batched(at, commands, WITHIN);
+    return {
+        said: all.map((one) => one.said).filter((one) => one !== ''),
+        refused: all.filter((one) => !one.ok).map((one) => one.command),
+    };
+}
+export function settling(at, all, skip = []) {
+    const mine = all
+        .filter((one) => word(one.by) !== '' && word(one.runs) !== '' && word(one.by) !== word(one.runs) && !skip.includes(word(one.by)))
+        .filter((one, order, every) => every.findIndex((each) => word(each.by) === word(one.by)) === order);
+    const ran = [];
+    let round = 0;
+    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 unhappy = mine.filter((one) => asking.includes(word(one.runs)));
+        if (unhappy.length === 0)
+            return { ran, unsettled: [], rounds: round };
+        const still = unhappy.map((one) => word(one.runs));
+        const seen = before;
+        if (seen !== undefined && still.length === seen.length && still.every((one) => seen.includes(one))) {
+            return { ran, unsettled: still, rounds: round };
+        }
+        before = still;
+        const writing = batch(at, unhappy.map((one) => word(one.by)));
+        for (const said of writing.said)
+            ran.push(said);
+        const refused = unhappy.filter((one) => writing.refused.includes(word(one.by))).map((one) => word(one.runs));
+        if (refused.length === unhappy.length)
+            return { ran, unsettled: refused, rounds: round };
+    }
+    return { ran, unsettled: batch(at, mine.map((one) => word(one.runs))).refused, rounds: round };
+}

package/dist/core/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};