@prestack/thread 0.0.1

package/dist/integrity/slopnators/sl_ungoverned_island.js

@@ -0,0 +1,58 @@
+import { here, islandsDeclared } from "./sl_unthreaded.js";
+import { findTree } from "../../core/tree.js";
+const TREE = `${findTree().name}/`;
+const GOVERNS = /^\s*governs:\s*'([^']+)'/gm;
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (!path.startsWith(TREE))
+            return false;
+        let islands;
+        try {
+            islands = islandsDeclared().map((one) => one.id);
+        }
+        catch {
+            return 'this file cannot be parsed, so the islands the tree declares were never read and nothing a law threaded to govern was measured';
+        }
+        for (const match of at.text.matchAll(GOVERNS)) {
+            const governed = match[1] ?? '';
+            if (islands.includes(governed))
+                continue;
+            return `a law governs "${governed}" and the tree declares no island by that name, so the rule reads as coverage of a kind nobody can declare`;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'threads/_governed_probe.ts',
+                        source: "export const L: Constraint = {\n  id: 'a-law',\n  governs: 'no-island-by-this-name',\n}\n",
+                    },
+                ],
+                at: 'threads/_governed_probe.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'threads/_governed_probe.ts',
+                        source: "export const L: Constraint = {\n  id: 'a-law',\n  governs: 'entities',\n}\n",
+                    },
+                ],
+                at: 'threads/_governed_probe.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'threads/_governed_probe.ts',
+                        source: "export const M: Islanding = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['app/_declare/events.ts'] },\n  ],\n}\n",
+                    },
+                ],
+                at: 'threads/_governed_probe.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unkept_rows.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unkept_rows.js

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+const STORES = 'src/stores';
+/* What hands an operation its seams, seeded once and then the app's own. */
+const SEAMS = 'src/seams.ts';
+/* What the declarations settle, which the seams file is expected to hand on. */
+const DECLARED = 'DECLARED';
+/*
+ * WHAT THIS READS, AND WHY IT READS THAT RATHER THAN THE TARGETS SHEET.
+ *
+ * A target that keeps entities derives a store of its own, written by `thread schema` into
+ * `src/stores/<target>.ts`. So one of those files existing IS the fact that this app declares
+ * somewhere to keep rows — already resolved, by the command that resolved it, with no second reading
+ * of what a reach can hold and no chance of the two disagreeing about it.
+ *
+ * Where rows go is settled in `src/_generated/seams.ts`, which `thread capabilities` writes from those
+ * stores and refuses when it drifts. The one place it can still go wrong is `src/seams.ts`, which is
+ * the app's own: an app that stops handing on what was settled there hands its operations a store
+ * that keeps nothing, while the tables are written, the migrations are written, and the gate is green.
+ */
+function held(root, at) {
+    const path = resolve(root, at);
+    try {
+        return existsSync(path) ? readFileSync(path, 'utf8') : '';
+    }
+    catch {
+        return '';
+    }
+}
+function derived(root) {
+    const at = resolve(root, STORES);
+    try {
+        return existsSync(at) ? readdirSync(at).filter((one) => one.endsWith('.ts')) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export const slopnator = {
+    checks: (root) => {
+        const stores = derived(root);
+        if (stores.length === 0)
+            return [];
+        /*
+         * AN APP WITH NOTHING THAT HANDS A STORE TO AN OPERATION IS NOT KEEPING ROWS THROUGH ONE, SO
+         * THERE IS NOTHING TO REFUSE.
+         *
+         * The seams file is seeded by `thread capabilities`, which ships in the operations package — so
+         * an app that attached data and integrity and nothing else has no seams and no command that
+         * seeds one. Its absence means rows go nowhere yet, which is a state to pass rather than refuse:
+         * nothing is being lost, because nothing is being kept.
+         */
+        const where = held(root, SEAMS);
+        if (where === '')
+            return [];
+        if (where.includes(DECLARED))
+            return [];
+        return [
+            `${STORES} holds ${stores.join(', ')} and ${SEAMS} no longer hands on ${DECLARED}, so every row this app keeps goes ` +
+                'somewhere that is gone the moment it stops. The tables are written, the migrations are written, the gate is ' +
+                `green, and the database is never opened. Spread ${DECLARED} back into SEAMS, or name its store there`,
+        ];
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
+                    {
+                        at: 'src/seams.ts',
+                        source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
+                    },
+                ],
+                at: 'src/seams.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    { at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' },
+                    {
+                        at: 'src/seams.ts',
+                        source: "import { DECLARED } from './_generated/seams.ts'\n\nexport const SEAMS = { ...DECLARED }\n",
+                    },
+                ],
+                at: 'src/seams.ts',
+            },
+            /* An app that derived a store and has nothing handing one to an operation — data attached, operations not. */
+            {
+                files: [{ at: 'src/stores/pl_probe.ts', source: 'export const store = {}\n' }],
+                at: 'src/seams.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'src/seams.ts',
+                        source: "import { inMemorySeams } from '../../operations/memory.ts'\n\nexport const SEAMS = inMemorySeams().seams\n",
+                    },
+                ],
+                at: 'src/seams.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unnamed_island.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unnamed_island.js

@@ -0,0 +1,37 @@
+import { declaresIsland, here, islandsDeclared } from "./sl_unthreaded.js";
+export const slopnator = {
+    holds: (_node, at) => {
+        const schema = declaresIsland(at.text);
+        if (schema === undefined)
+            return false;
+        const path = here(at.filename);
+        if (islandsDeclared().some((island) => island.at === path))
+            return false;
+        return (`${schema}IslandSchema is an island and no row in the tree names it, so nothing states what it governs and ` +
+            'no law can reach it — the kind is declarable and every rule about where it may be declared is absent');
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
+                        source: 'export const ThingIslandSchema = z.strictObject({\n  specVersion: z.literal(1),\n})\n',
+                    },
+                ],
+                at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
+                        source: 'export const ThingSchema = z.strictObject({\n  name: z.string(),\n})\n',
+                    },
+                ],
+                at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unpaired_member.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unpaired_member.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { foldersGoverned, here, islandsDeclared, rowsIn } from "./sl_unthreaded.js";
+import { findTree } from "../../core/tree.js";
+const ROOT = findTree().at;
+const TREE = `${findTree().name}/`;
+const seeding = (one) => {
+    const folder = foldersGoverned(one.governs)[0];
+    if (folder === undefined || one.tree === undefined || one.member === undefined)
+        return undefined;
+    return { island: one.id, folder, tree: one.tree, member: one.member };
+};
+const islandsSeeding = () => islandsDeclared().flatMap((one) => {
+    const held = seeding(one);
+    return held === undefined ? [] : [held];
+});
+const declares = (island) => new RegExp(`^export const ${island.toUpperCase()}\\b`, 'm');
+const exports = (member) => new RegExp(`^export const ${member}\\b`, 'm');
+function seededNames(text) {
+    const found = [];
+    for (const row of rowsIn(text)) {
+        if (row.list !== undefined || row.id === undefined)
+            continue;
+        found.push(`${row.id}.ts`);
+    }
+    return found;
+}
+function onDisk(folder) {
+    const dir = resolve(ROOT, folder);
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir).filter((name) => name.endsWith('.ts'));
+    }
+    catch {
+        return [];
+    }
+}
+function declaredNames(one) {
+    const path = resolve(ROOT, one.tree);
+    if (!existsSync(path))
+        return [];
+    try {
+        return seededNames(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        for (const one of islandsSeeding()) {
+            if (path.startsWith(TREE)) {
+                if (!declares(one.island).test(at.text))
+                    continue;
+                let wanted;
+                try {
+                    wanted = seededNames(at.text);
+                }
+                catch {
+                    return 'this file cannot be parsed, so the members it declares were never read and no file was measured against them';
+                }
+                const found = onDisk(one.folder);
+                for (const name of wanted) {
+                    if (found.includes(name))
+                        continue;
+                    return `a row here declares ${one.member} \`${name.replace(/\.ts$/, '')}\` and ${one.folder}${name} is not on disk, so the row brings nothing into existence — run \`pnpm member:seed\``;
+                }
+                return false;
+            }
+            if (!path.startsWith(one.folder))
+                continue;
+            const name = path.slice(one.folder.length);
+            if (!name.endsWith('.ts') || name.includes('/'))
+                continue;
+            if (!declaredNames(one).includes(name)) {
+                return `${one.folder} holds ${one.member} \`${name.replace(/\.ts$/, '')}\` and no row in ${one.tree} declares it, so it can act while nothing brought it into existence — declare the row first and let \`pnpm member:seed\` write the file, or delete it`;
+            }
+            if (!exports(one.member).test(at.text)) {
+                return `${name} is declared and exports no \`${one.member}\`, so the row and the file both exist and the ${one.member} still loads as nothing — write it into the template the seeder left`;
+            }
+            return false;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'threads/_member_probe.ts',
+                        source: "export const OPERATIONS: readonly Member[] = [\n  {\n    id: 'wf_unseeded_probe',\n    at: 'threads/operations.ts',\n  },\n]\n",
+                    },
+                ],
+                at: 'threads/_member_probe.ts',
+            },
+            {
+                files: [{ at: 'operations/wf_undeclared_probe.ts', source: 'export const operation = { id: 1 }\n' }],
+                at: 'operations/wf_undeclared_probe.ts',
+            },
+        ],
+        right: [
+            {
+                files: [{ at: 'threads/_member_probe.ts', source: 'export const OPERATIONS: readonly Member[] = []\n' }],
+                at: 'threads/_member_probe.ts',
+            },
+            {
+                files: [{ at: 'threads/_member_quiet.ts', source: 'export const NOTHING = []\n' }],
+                at: 'threads/_member_quiet.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unpaired_slopnator.d.ts

@@ -0,0 +1,2 @@
+import { type Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unpaired_slopnator.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { SEEDED, SHIPPED, slopnatorName } from "../slopnator.js";
+import { here } from "./sl_unthreaded.js";
+import { findTree } from "../../core/tree.js";
+const ROOT = findTree().at;
+const TREE = `${findTree().name}/`;
+const ID = /^ {4}id:\s*'([^']+)'/gm;
+const DECLARES = /^(?:export )?const (CONSTRAINTS|RULES)\b/m;
+const idsIn = (text) => [...text.matchAll(ID)].map((one) => one[1] ?? '');
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (path.startsWith(TREE) && DECLARES.test(at.text)) {
+            for (const id of idsIn(at.text)) {
+                const name = `${slopnatorName(id)}.ts`;
+                if ([SHIPPED, resolve(ROOT, SEEDED)].some((dir) => existsSync(join(dir, name))))
+                    continue;
+                return `"${id}" names "${slopnatorName(id)}", and no such file is in ${SEEDED}/ or shipped with the package — one that cannot run registers, reports nothing, and is indistinguishable from one being obeyed. Seed it`;
+            }
+            return false;
+        }
+        const home = [SEEDED].find((dir) => path.startsWith(`${dir}/`));
+        if (home === undefined)
+            return false;
+        const file = path.slice(home.length + 1);
+        if (!file.startsWith('sl_') || !file.endsWith('.ts'))
+            return false;
+        const declared = [join(SHIPPED, '..', 'constraint.ts'), resolve(ROOT, `${TREE}rules.ts`)]
+            .map((one) => { try {
+            return readFileSync(one, 'utf8');
+        }
+        catch {
+            return '';
+        } })
+            .join('\n');
+        const named = new Set(idsIn(declared).map((id) => slopnatorName(id)));
+        if (named.has(file.replace(/\.ts$/, '')))
+            return false;
+        return `${path} is named by no law, so it governs nothing while looking like enforcement to anybody reading the directory — delete it, or declare the law that needs it. A law renamed makes this a \`git mv\`, not a second file`;
+    },
+    proves: {
+        wrong: [
+            "const CONSTRAINTS = [\n  {\n    id: 'nothing-names-this-slopnator',\n  },\n]",
+            {
+                files: [{ at: 'threads/slopnators/sl_no_law_names_this.ts', source: "export const slopnator = { on: [], holds: () => false }\n" }],
+                at: 'threads/slopnators/sl_no_law_names_this.ts',
+            },
+        ],
+        right: [
+            "const CONSTRAINTS = [\n  {\n    id: 'no-comment',\n  },\n]",
+            "const CONSTRAINTS = [\n  {\n    id: 'no-comment',\n  },\n  {\n    id: 'unthreaded',\n  },\n]",
+            'export const PLAIN = 1',
+            {
+                files: [{ at: 'threads/slopnators/not_a_walk.ts', source: 'export const HELPER = 1\n' }],
+                at: 'threads/slopnators/not_a_walk.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unprefixed_member.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unprefixed_member.js

@@ -0,0 +1,126 @@
+import { inCode, listBounds, matched } from "../../core/rows.js";
+import { PREFIXES } from "../../core/thread.js";
+import { here, parses, unreadable } from "./sl_unthreaded.js";
+const MEMBERS = 'MEMBERS';
+/*
+ * Which prefixes a tree file's member list may hold.
+ *
+ * The file is the key because the list is named the same in both: `MEMBERS` in the operations tree
+ * holds what an app can be asked to do, and `MEMBERS` in the nodes tree holds the spans an operation
+ * is built from. Nothing in TypeScript separates them — both are arrays of rows carrying a string id
+ * — so an operation declared among the nodes, or a node among the operations, typechecks, attaches,
+ * seeds a body and reads as agreed by everything downstream.
+ *
+ * What an operation may wear is not written here. `@thread/core/thread` pairs each word an
+ * operation can be with the prefix its id takes, and `thread create` puts that prefix on — so the
+ * command that makes them and the law that refuses them read one list. Written out again here,
+ * a kind added over there would be a kind this refuses.
+ */
+const TAKES = {
+    'operations.ts': Object.values(PREFIXES),
+    'nodes.ts': ['nd_', 'sm_'],
+};
+const ID = /\bid:\s*'((?:[^'\\]|\\.)*)'/;
+/*
+ * The id of every row sitting directly in the list, and no deeper.
+ *
+ * Depth is the whole of it: a member row states its own id, and the `seeds` and `derives` rows under
+ * it state theirs, which are neither operations nor nodes — `wf_send_invoice_body` is a body, not
+ * something an app can be asked to do. Reading every id in the list would refuse those children for
+ * lacking a prefix they were never meant to wear.
+ *
+ * The braces are read off `inCode`, not off the raw text. Counting characters directly desynced on a
+ * `describes:` holding a brace, and this package already ships the mask and the matcher for exactly
+ * that — a second, weaker walker beside them is the drift they exist to prevent.
+ */
+function directly(text, open, close) {
+    const code = inCode(text);
+    const found = [];
+    for (let at = open; at < close; at += 1) {
+        if (code[at] !== true || text[at] !== '{')
+            continue;
+        const ends = matched(text, code, at, '{', '}');
+        if (ends === -1 || ends > close)
+            break;
+        const said = ID.exec(text.slice(at, ends))?.[1];
+        if (said !== undefined)
+            found.push(said);
+        at = ends;
+    }
+    return found;
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (unreadable(path, at.text) !== undefined)
+            return false;
+        if (!parses(path))
+            return false;
+        const takes = TAKES[path.slice(path.lastIndexOf('/') + 1)];
+        if (takes === undefined)
+            return false;
+        const text = String(at.text);
+        const where = listBounds(text, MEMBERS);
+        if (where === undefined)
+            return false;
+        for (const said of directly(text, where.open, where.close)) {
+            if (takes.some((one) => said.startsWith(one)))
+                continue;
+            return (`\`${said}\` sits in \`${MEMBERS}\` here, and this list takes ${takes.map((one) => `\`${one}\``).join(', ')}. ` +
+                'A prefix is what says which of the two a row is, and a row wearing the wrong one is declared as ' +
+                'something it is not, seeds a body of the wrong shape, and is read as agreed by everything downstream');
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: '_threads/operations.ts',
+                        source: "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'nd_teleport',\n    at: '_threads/operations.ts',\n    describes: 'a node wearing an operation list',\n    version: 1,\n  },\n]\n",
+                    },
+                ],
+                at: '_threads/operations.ts',
+            },
+            {
+                files: [
+                    {
+                        at: '_threads/nodes.ts',
+                        source: "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  at: '_threads/nodes.ts',\n  describes: 'the spans an operation is built from',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'wf_send_invoice',\n    at: '_threads/nodes.ts',\n    describes: 'an operation wearing a node list',\n    version: 1,\n  },\n]\n",
+                    },
+                ],
+                at: '_threads/nodes.ts',
+            },
+            {
+                files: [
+                    {
+                        at: '_threads/operations.ts',
+                        source: "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'sendInvoice',\n    at: '_threads/operations.ts',\n    describes: 'no prefix at all',\n    version: 1,\n  },\n]\n",
+                    },
+                ],
+                at: '_threads/operations.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: '_threads/operations.ts',
+                        source: "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const OPERATIONS: Threaded = {\n  id: 'operations',\n  at: '_threads/operations.ts',\n  describes: 'what an app can be asked to do',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'wf_send_invoice',\n    at: '_threads/operations.ts',\n    describes: 'sends an invoice',\n    version: 1,\n    seeds: [\n      {\n        id: 'wf_send_invoice_body',\n        at: 'operations/wf_send_invoice.ts',\n        describes: 'the operation itself',\n      },\n    ],\n  },\n]\n",
+                    },
+                ],
+                at: '_threads/operations.ts',
+            },
+            {
+                files: [
+                    {
+                        at: '_threads/nodes.ts',
+                        source: "import type { Member, Threaded } from '../../core/thread.ts'\n\nexport const NODES: Threaded = {\n  id: 'nodes',\n  at: '_threads/nodes.ts',\n  describes: 'the spans an operation is built from',\n  version: 1,\n}\n\nexport const MEMBERS: readonly Member[] = [\n  {\n    id: 'nd_teleport',\n    at: '_threads/nodes.ts',\n    describes: 'a step this app added',\n    version: 1,\n  },\n]\n",
+                    },
+                ],
+                at: '_threads/nodes.ts',
+            },
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unseamed_reach.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_unseamed_reach.js

@@ -0,0 +1,73 @@
+import { isBuiltin } from 'node:module';
+import { parser } from 'typescript-eslint';
+const CODE = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const MENTIONS = /\bimport\b|\brequire\s*\(/;
+function reached(node, seen, found) {
+    if (typeof node !== 'object' || node === null)
+        return;
+    if (seen.has(node))
+        return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+        for (const each of node)
+            reached(each, seen, found);
+        return;
+    }
+    const one = node;
+    const type = one['type'];
+    if (type === 'ImportDeclaration' || type === 'ImportExpression' || type === 'ExportNamedDeclaration' || type === 'ExportAllDeclaration') {
+        const source = one['source'];
+        if (typeof source?.value === 'string')
+            found(source.value);
+    }
+    if (type === 'CallExpression') {
+        const callee = one['callee'];
+        if (callee?.type === 'Identifier' && callee.name === 'require') {
+            const first = one['arguments']?.[0];
+            if (typeof first?.value === 'string')
+                found(first.value);
+        }
+    }
+    for (const held of Object.values(one))
+        reached(held, seen, found);
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        if (!CODE.test(at.filename))
+            return false;
+        const text = String(at.text);
+        if (!MENTIONS.test(text))
+            return false;
+        let ast;
+        try {
+            ast = parser.parseForESLint(text, {
+                range: true,
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+                ecmaFeatures: { jsx: true },
+            }).ast;
+        }
+        catch {
+            return false;
+        }
+        const taken = new Set();
+        reached(ast, new WeakSet(), (one) => {
+            if (isBuiltin(one))
+                taken.add(one);
+        });
+        if (taken.size === 0)
+            return false;
+        return `this reaches ${[...taken].sort().join(', ')} straight from the runtime, and a node is handed everything it may touch`;
+    },
+    proves: {
+        wrong: [
+            "import { readFileSync } from 'node:fs'\nexport const node = readFileSync\n",
+            "const { spawn } = require('child_process')\nexport const node = spawn\n",
+            "export const node = async () => await import('node:net')\n",
+        ],
+        right: [
+            "import { nd_read } from '../../operations/nodes.ts'\nexport const node = nd_read(async (hands) => await hands.store.get('a', 'b'))\n",
+            "import type { In } from './input.ts'\nexport const node = null as unknown as In\n",
+        ],
+    },
+};

package/dist/integrity/slopnators/sl_unthreaded.d.ts

@@ -0,0 +1,56 @@
+import type { Slopnator } from '../slopnator.ts';
+export interface Reach {
+    readonly list?: 'declares' | 'derives' | 'seeds';
+    readonly at?: string;
+    readonly id?: string;
+    readonly describes?: string;
+    readonly version?: number;
+    readonly governs?: readonly string[];
+    readonly wears?: readonly string[];
+}
+export interface Meaning {
+    readonly id: string;
+    readonly describes: string;
+}
+export declare const here: (filename: string) => string;
+export declare function atsIn(text: string, only?: ReadonlySet<string>): readonly string[];
+export declare const rowsIn: (text: string) => readonly Reach[];
+export type Governed = {
+    readonly kind: 'file';
+    readonly at: string;
+} | {
+    readonly kind: 'folder';
+    readonly under: string;
+} | {
+    readonly kind: 'pattern';
+    readonly matching: string;
+    readonly under: string;
+};
+export declare function governedBy(one: string): Governed;
+export declare const filesGoverned: (all: readonly string[]) => readonly string[];
+export declare const foldersGoverned: (all: readonly string[]) => readonly string[];
+export declare function governs(all: readonly string[], path: string): boolean;
+export interface Declared {
+    readonly id: string;
+    readonly at: string;
+    readonly describes: string;
+    readonly governs: readonly string[];
+    readonly define?: string;
+    readonly tree?: string;
+    readonly member?: string;
+}
+export declare function islandsDeclared(): readonly Declared[];
+export declare const declaresIsland: (text: string) => string | undefined;
+export declare function meaningsIn(text: string): readonly Meaning[];
+export interface Index {
+    readonly reached: ReadonlySet<string>;
+    readonly declared: ReadonlyMap<string, number>;
+    readonly meanings: ReadonlyMap<string, ReadonlySet<string>>;
+}
+export declare function index(): Index;
+export declare function forget(): void;
+export declare const threaded: () => ReadonlySet<string>;
+export declare const parses: (path: string) => boolean;
+export declare function unreadable(path: string, text: string): string | undefined;
+export declare const names: (path: string, text: string) => readonly string[];
+export declare const slopnator: Slopnator;