@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnator.d.ts

@@ -3,18 +3,6 @@ export declare const NOT_WRITTEN: unique symbol;
 export declare const SHIPPED: string;
 export declare const SEEDED: string;
 export declare const ROOT: string;
-export declare const DEPTH = "THREAD_DEPTH";
-export declare const CEILING = 1;
-export declare const SPAWN_TIMEOUT = 120000;
-export declare const SPAWN_BUFFER: number;
-export declare function nested(): boolean;
-export declare function ran(command: string, options: {
-    readonly cwd: string;
-    readonly args?: readonly string[];
-}): {
-    readonly status: number | null;
-    readonly said: string;
-} | undefined;
 export interface SlopnatorContext {
     readonly filename: string;
     readonly text: string;
@@ -53,7 +41,9 @@ export interface Byproduct {
     readonly content: string;
 }
 export declare function slopnatorName(rule: string): string;
-export declare function names(fragment: string, path: readonly string[]): boolean;
+export declare function region(fragment: string, path: readonly string[]): boolean;
+export declare function derivedHere(): ReadonlySet<string> | undefined;
+export declare function subject(rule: Constraint): boolean;
 export declare function governs(rule: Constraint, filename: string): boolean;
 export declare class UnloadableSlopnatorError extends Error {
     constructor(rule: string, at: string, because: string);

package/dist/integrity/slopnator.js

@@ -6,14 +6,15 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "../core/files.js";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from '../integrations/disk.js';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { invoked } from "../core/invoked.js";
-import { listBounds, quoted, withSeed } from "../core/rows.js";
-import { CONSTRAINTS } from "./constraint.js";
-import { findTree, inTree } from "../core/tree.js";
+import { descend } from '../core/descend.js';
+import { governs as reaches, islandsDeclared } from './slopnators/sl_unthreaded.js';
+import { invoked } from '../core/invoked.js';
+import { listBounds, quoted, withSeed } from '../core/rows.js';
+import { CONSTRAINTS } from './constraint.js';
+import { findTree, inTree } from '../core/tree.js';
 export const NOT_WRITTEN = Symbol.for('thread.slopnator.not_written');
 const HOME = dirname(fileURLToPath(import.meta.url));
 export const SHIPPED = `${HOME}/slopnators`;
@@ -22,29 +23,6 @@ function homes(root) {
     return [SHIPPED, join(root, SEEDED)];
 }
 export const ROOT = `${findTree().at}/`;
-export const DEPTH = 'THREAD_DEPTH';
-export const CEILING = 1;
-export const SPAWN_TIMEOUT = 120_000;
-export const SPAWN_BUFFER = 8 * 1024 * 1024;
-export function nested() {
-    return Number(process.env[DEPTH] ?? '0') >= CEILING;
-}
-export function ran(command, options) {
-    if (nested())
-        return undefined;
-    const depth = Number(process.env[DEPTH] ?? '0');
-    const out = spawnSync(command, [...(options.args ?? [])], {
-        shell: options.args === undefined,
-        cwd: options.cwd,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: SPAWN_TIMEOUT,
-        killSignal: 'SIGKILL',
-        maxBuffer: SPAWN_BUFFER,
-        env: { ...process.env, [DEPTH]: String(depth + 1) },
-    });
-    return { status: out.status, said: `${String(out.stdout ?? '')}${String(out.stderr ?? '')}` };
-}
 export const reads = (one) => 'holds' in one;
 export const visits = (one) => 'holds' in one && one.on !== undefined;
 export const sweeps = (one) => 'holds' in one && one.on === undefined;
@@ -63,7 +41,10 @@ function wanted(fragment) {
     const all = parts(fragment);
     return all[0] === CANONICAL_TREE ? [TREE, ...all.slice(1)] : all;
 }
-export function names(fragment, path) {
+function holding(want, path, from) {
+    return want.every((part, step) => part === path[from + step]);
+}
+export function region(fragment, path) {
     if (fragment === '.')
         return true;
     const want = wanted(fragment);
@@ -71,17 +52,57 @@ export function names(fragment, path) {
         return false;
     if (!fragment.endsWith('/'))
         return want.join('/') === path.join('/');
-    for (let at = 0; at + want.length < path.length; at += 1) {
-        if (want.every((part, step) => part === path[at + step]))
-            return true;
+    return want.length < path.length && holding(want, path, 0);
+}
+let written;
+export function derivedHere() {
+    if (written !== undefined)
+        return written;
+    try {
+        const found = new Set();
+        for (const [at, threadings] of descend().threaded) {
+            if (threadings.some((one) => one.list === 'derives' && (one.row.by ?? one.row.runs) !== undefined))
+                found.add(at);
+        }
+        written = found;
+        return written;
+    }
+    catch {
+        return undefined;
     }
-    return false;
+}
+const islands = new WeakMap();
+function islandsHere() {
+    try {
+        const pass = descend();
+        const known = islands.get(pass);
+        if (known !== undefined)
+            return known;
+        const named = new Map(islandsDeclared().map((one) => [one.id, one.governs]));
+        islands.set(pass, named);
+        return named;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function subject(rule) {
+    if (rule.governs === undefined)
+        return true;
+    const named = islandsHere();
+    return named === undefined || named.has(rule.governs);
 }
 export function governs(rule, filename) {
-    const path = parts(filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename);
-    if ((rule.where.except ?? []).some((fragment) => names(fragment, path)))
+    const under = filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename;
+    const path = parts(under);
+    if (rule.governs !== undefined) {
+        const body = islandsHere()?.get(rule.governs);
+        if (body !== undefined && reaches(body, under))
+            return false;
+    }
+    if (!rule.where.paths.some((fragment) => region(fragment, path)))
         return false;
-    return rule.where.paths.some((fragment) => names(fragment, path));
+    return derivedHere()?.has(under) !== true;
 }
 export class UnloadableSlopnatorError extends Error {
     constructor(rule, at, because) {
@@ -105,7 +126,7 @@ export async function load(root, all) {
     for (const rule of all) {
         const name = slopnatorName(rule.id);
         const at = homes(root)
-            .flatMap((dir) => [join(dir, `${name}.ts`), join(dir, `${name}.js`)])
+            .flatMap((dir) => [join(dir, `${name}.js`), join(dir, `${name}.ts`)])
             .find((one) => existsSync(one));
         if (at === undefined)
             continue;

package/dist/integrity/slopnator.ts

@@ -1,8 +1,9 @@
-import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync, readdirSync, writeFileSync } from '../core/files.ts'
+import { existsSync, readFileSync, readdirSync, writeFileSync } from '../integrations/disk.ts'
 import { dirname, join } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
+import { descend } from '../core/descend.ts'
+import { governs as reaches, islandsDeclared } from './slopnators/sl_unthreaded.ts'
 import { invoked } from '../core/invoked.ts'
 
 import { listBounds, quoted, withSeed } from '../core/rows.ts'
@@ -24,34 +25,6 @@ function homes(root: string): readonly string[] {
 
 export const ROOT = `${findTree().at}/`
 
-export const DEPTH = 'THREAD_DEPTH'
-
-export const CEILING = 1
-
-export const SPAWN_TIMEOUT = 120_000
-
-export const SPAWN_BUFFER = 8 * 1024 * 1024
-
-export function nested(): boolean {
-  return Number(process.env[DEPTH] ?? '0') >= CEILING
-}
-
-export function ran(command: string, options: { readonly cwd: string; readonly args?: readonly string[] }): { readonly status: number | null; readonly said: string } | undefined {
-  if (nested()) return undefined
-  const depth = Number(process.env[DEPTH] ?? '0')
-  const out = spawnSync(command, [...(options.args ?? [])], {
-    shell: options.args === undefined,
-    cwd: options.cwd,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: SPAWN_TIMEOUT,
-    killSignal: 'SIGKILL',
-    maxBuffer: SPAWN_BUFFER,
-    env: { ...process.env, [DEPTH]: String(depth + 1) },
-  })
-  return { status: out.status, said: `${String(out.stdout ?? '')}${String(out.stderr ?? '')}` }
-}
-
 export interface SlopnatorContext {
   readonly filename: string
   readonly text: string
@@ -119,21 +92,64 @@ function wanted(fragment: string): readonly string[] {
   return all[0] === CANONICAL_TREE ? [TREE, ...all.slice(1)] : all
 }
 
-export function names(fragment: string, path: readonly string[]): boolean {
+function holding(want: readonly string[], path: readonly string[], from: number): boolean {
+  return want.every((part, step) => part === path[from + step])
+}
+
+export function region(fragment: string, path: readonly string[]): boolean {
   if (fragment === '.') return true
   const want = wanted(fragment)
   if (want.length === 0) return false
   if (!fragment.endsWith('/')) return want.join('/') === path.join('/')
-  for (let at = 0; at + want.length < path.length; at += 1) {
-    if (want.every((part, step) => part === path[at + step])) return true
+  return want.length < path.length && holding(want, path, 0)
+}
+
+let written: ReadonlySet<string> | undefined
+
+export function derivedHere(): ReadonlySet<string> | undefined {
+  if (written !== undefined) return written
+  try {
+    const found = new Set<string>()
+    for (const [at, threadings] of descend().threaded) {
+      if (threadings.some((one) => one.list === 'derives' && (one.row.by ?? one.row.runs) !== undefined)) found.add(at)
+    }
+    written = found
+    return written
+  } catch {
+    return undefined
+  }
+}
+
+const islands = new WeakMap<object, ReadonlyMap<string, readonly string[]>>()
+
+function islandsHere(): ReadonlyMap<string, readonly string[]> | undefined {
+  try {
+    const pass = descend()
+    const known = islands.get(pass)
+    if (known !== undefined) return known
+    const named = new Map(islandsDeclared().map((one) => [one.id, one.governs]))
+    islands.set(pass, named)
+    return named
+  } catch {
+    return undefined
   }
-  return false
+}
+
+export function subject(rule: Constraint): boolean {
+  if (rule.governs === undefined) return true
+  const named = islandsHere()
+  return named === undefined || named.has(rule.governs)
 }
 
 export function governs(rule: Constraint, filename: string): boolean {
-  const path = parts(filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename)
-  if ((rule.where.except ?? []).some((fragment) => names(fragment, path))) return false
-  return rule.where.paths.some((fragment) => names(fragment, path))
+  const under = filename.startsWith(ROOT) ? filename.slice(ROOT.length) : filename
+  const path = parts(under)
+  if (rule.governs !== undefined) {
+    const body = islandsHere()?.get(rule.governs)
+    if (body !== undefined && reaches(body, under)) return false
+  }
+  if (!rule.where.paths.some((fragment) => region(fragment, path))) return false
+  return derivedHere()?.has(under) !== true
 }
 
 export class UnloadableSlopnatorError extends Error {
@@ -164,7 +180,7 @@ export async function load(root: string, all: readonly Constraint[]): Promise<Re
   for (const rule of all) {
     const name = slopnatorName(rule.id)
     const at = homes(root)
-      .flatMap((dir) => [join(dir, `${name}.ts`), join(dir, `${name}.js`)])
+      .flatMap((dir) => [join(dir, `${name}.js`), join(dir, `${name}.ts`)])
       .find((one) => existsSync(one))
     if (at === undefined) continue
 

package/dist/integrity/slopnators/sl_broken_lineage.js

@@ -1,5 +1,5 @@
-import { here, names, threaded, unreadable } from "./sl_unthreaded.js";
-import { findTree } from "../../core/tree.js";
+import { here, names, threaded, unreadable } from './sl_unthreaded.js';
+import { findTree } from '../../core/tree.js';
 const THREAD_AT = `${findTree().name}/thread.ts`;
 export const slopnator = {
     holds: (_node, at) => {

package/dist/integrity/slopnators/sl_declared_elsewhere.js

@@ -1,4 +1,4 @@
-import { filesGoverned, here, islandsDeclared } from "./sl_unthreaded.js";
+import { filesGoverned, here, islandsDeclared } from './sl_unthreaded.js';
 const sentence = (describes) => `${describes.split(/ — |\. /)[0] ?? describes}.`;
 export const slopnator = {
     holds: (_node, at) => {

package/dist/integrity/slopnators/sl_derived_drift.js

@@ -1,8 +1,8 @@
-import { readFileSync } from "../../core/files.js";
+import { readFileSync } from '../../integrations/disk.js';
 import { resolve } from 'node:path';
-import { atsIn } from "./sl_unthreaded.js";
-import { reached } from "../../core/descend.js";
-import { findTree } from "../../core/tree.js";
+import { atsIn } from './sl_unthreaded.js';
+import { reached } from '../../core/descend.js';
+import { findTree } from '../../core/tree.js';
 const ROOT = `${findTree().at}/`;
 export function derivations(root) {
     const found = [];

package/dist/integrity/slopnators/sl_derived_drift.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from '../../core/files.ts'
+import { readFileSync } from '../../integrations/disk.ts'
 import { resolve } from 'node:path'
 
 import type { Slopnator } from '../slopnator.ts'

package/dist/integrity/slopnators/sl_door_in_a_node.js

@@ -0,0 +1,220 @@
+import { resolve } from 'node:path';
+import ts from 'typescript';
+import { ROOT, configured, hosting } from '../../core/descend.js';
+import { kind, readFileSync } from '../../integrations/disk.js';
+import { OPENS } from '../../integrations/target.js';
+import { here } from './sl_unthreaded.js';
+const IMPORTED = 'import ';
+const MADE = 'new ';
+const RUNTIME = 'node:';
+const ANYWHERE = 'globalThis';
+const REQUIRED = 'require';
+const DECLARED = /\.d\.([cm]?)ts$/;
+const READABLE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
+const plain = (specifier) => (specifier.startsWith(RUNTIME) ? specifier.slice(RUNTIME.length) : specifier);
+function doors() {
+    const modules = new Map();
+    const globals = new Map();
+    const properties = new Map();
+    for (const [reach, spellings] of Object.entries(OPENS)) {
+        for (const spelling of spellings) {
+            const door = { reach, spelling };
+            if (spelling.startsWith(IMPORTED)) {
+                const rest = spelling.slice(IMPORTED.length);
+                const dot = rest.lastIndexOf('.');
+                modules.set(plain(dot === -1 || rest.slice(dot).includes('/') ? rest : rest.slice(0, dot)), door);
+                continue;
+            }
+            if (spelling.startsWith(MADE)) {
+                globals.set(spelling.slice(MADE.length), door);
+                continue;
+            }
+            if (spelling.includes('.'))
+                properties.set(spelling, door);
+            else
+                globals.set(spelling, door);
+        }
+    }
+    return { modules, globals, properties };
+}
+const DOORS = doors();
+const files = new Map();
+function parsed(at, text) {
+    const held = files.get(text);
+    if (held !== undefined)
+        return held;
+    const file = ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, at.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    files.set(text, file);
+    return file;
+}
+function brought(file) {
+    const found = [];
+    const line = (node) => file.getLineAndCharacterOfPosition(node.getStart(file)).line + 1;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && node.importClause?.isTypeOnly !== true && ts.isStringLiteral(node.moduleSpecifier)) {
+            found.push({ specifier: node.moduleSpecifier.text, line: line(node) });
+        }
+        if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier)) {
+            found.push({ specifier: node.moduleSpecifier.text, line: line(node) });
+        }
+        if (ts.isCallExpression(node)) {
+            const first = node.arguments[0];
+            const loads = node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === REQUIRED);
+            if (loads && first !== undefined && ts.isStringLiteral(first))
+                found.push({ specifier: first.text, line: line(node) });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return found;
+}
+const binds = (node) => {
+    const parent = node.parent;
+    return ((ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent) ||
+        ts.isImportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent)) &&
+        parent.name === node);
+};
+const named = (node) => node.parent?.name === node;
+const opened = new Map();
+function opening(at, text) {
+    if (opened.has(text))
+        return opened.get(text);
+    const file = parsed(at, text);
+    let found;
+    for (const one of brought(file))
+        found ??= DOORS.modules.get(plain(one.specifier));
+    const bound = new Set();
+    const collect = (node) => {
+        if (ts.isIdentifier(node) && binds(node))
+            bound.add(node.text);
+        ts.forEachChild(node, collect);
+    };
+    collect(file);
+    const visit = (node) => {
+        if (found !== undefined)
+            return;
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && !ts.isPartOfTypeNode(node)) {
+            const object = node.expression.text;
+            found = DOORS.properties.get(object + '.' + node.name.text) ?? (object === ANYWHERE ? DOORS.globals.get(node.name.text) : undefined);
+        }
+        if (found === undefined && ts.isIdentifier(node) && !named(node) && !ts.isPartOfTypeNode(node) && !bound.has(node.text)) {
+            found = DOORS.globals.get(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    opened.set(text, found);
+    return found;
+}
+let options;
+let host;
+function resolvedOf(specifier, from) {
+    options ??= configured().options;
+    host ??= hosting(options);
+    const found = ts.resolveModuleName(specifier, from, options, host).resolvedModule;
+    if (found === undefined)
+        return undefined;
+    const at = found.resolvedFileName;
+    if (!DECLARED.test(at))
+        return at;
+    const emitted = at.replace(DECLARED, '.$1js');
+    return kind(emitted) === 'file' ? emitted : undefined;
+}
+const readable = (at) => (READABLE.test(at) && kind(at) === 'file' ? readFileSync(at, 'utf8') : undefined);
+const shown = (chain, door) => chain.map((one) => '`' + one + '`').join(', which imports ') +
+    (door.spelling.startsWith(IMPORTED) ? ', which imports ' + door.spelling.slice(IMPORTED.length) : ', which reaches ' + door.spelling) +
+    ' — the ' +
+    door.reach +
+    ' reach, and no target declares it. Nothing prices that reach, replays it in a trial or refuses it. Declare the place with `thread create target`, require it on the operation, and call what the node is handed instead';
+function through(at, chain, seen) {
+    const text = readable(at);
+    if (text === undefined)
+        return undefined;
+    const door = opening(at, text);
+    if (door !== undefined)
+        return shown(chain, door);
+    for (const one of brought(parsed(at, text))) {
+        const next = resolvedOf(one.specifier, at);
+        if (next === undefined || seen.has(next))
+            continue;
+        seen.add(next);
+        const found = through(next, [...chain, one.specifier], seen);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (!READABLE.test(path))
+            return false;
+        const from = resolve(ROOT, path);
+        const seen = new Set([from]);
+        for (const one of brought(parsed(from, at.text))) {
+            const next = resolvedOf(one.specifier, from);
+            if (next === undefined || seen.has(next))
+                continue;
+            seen.add(next);
+            const found = through(next, [one.specifier], seen);
+            if (found !== undefined)
+                return 'line ' + String(one.line) + ': imports ' + found;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
+                    { at: 'operations/_probe_node.ts', source: "export { starts } from '../thread/integrations/cli.ts'\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+            {
+                files: [
+                    { at: 'thread/integrations/https.ts', source: "export const sendingHttp = async (address: string): Promise<number> => (await fetch(address)).status\n" },
+                    { at: 'src/_probe_helper.ts', source: "import { sendingHttp } from '../thread/integrations/https.ts'\n\nexport const status = (address: string): Promise<number> => sendingHttp(address)\n" },
+                    { at: 'operations/_probe_node.ts', source: "import { status } from '../src/_probe_helper.ts'\n\nexport const node = (address: string): Promise<number> => status(address)\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+            {
+                files: [
+                    { at: 'thread/integrations/disk.ts', source: "import * as disk from 'node:fs'\n\nexport const read = (at: string): string => disk.readFileSync(at, 'utf8')\n" },
+                    { at: 'operations/_probe_node.ts', source: "export const node = async (at: string): Promise<string> => (await import('../thread/integrations/disk.ts')).read(at)\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    { at: 'thread/operations/nodes.ts', source: "export const nd_action = <T>(run: T): T => run\n" },
+                    { at: 'operations/_probe_node.ts', source: "import { nd_action } from '../thread/operations/nodes.ts'\n\nexport const node = nd_action(async () => 1)\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+            {
+                files: [
+                    { at: 'thread/integrations/cli.ts', source: "import { spawn } from 'node:child_process'\n\nexport interface Ran {\n  readonly out: string\n}\n\nexport const starts = (program: string): void => {\n  spawn(program)\n}\n" },
+                    { at: 'operations/_probe_node.ts', source: "import type { Ran } from '../thread/integrations/cli.ts'\n\nexport const node = (ran: Ran): string => ran.out\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+            {
+                files: [
+                    { at: 'src/_probe_helper.ts', source: "const fetch = (said: string): string => said\n\nexport const shout = (said: string): string => fetch(said).toUpperCase()\n" },
+                    { at: 'operations/_probe_node.ts', source: "import { shout } from '../src/_probe_helper.ts'\n\nexport const node = (): string => shout('a')\n" },
+                ],
+                at: 'operations/_probe_node.ts',
+            },
+        ],
+    },
+};