@prestack/thread 0.0.1

package/dist/integrity/lsp/server.js

@@ -0,0 +1,171 @@
+import { relative as relativeTo, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { named } from "../../core/scope.js";
+import { report, SOURCE_NAME } from "./diagnostics.js";
+import { METHOD_NOT_FOUND } from "./protocol.js";
+const SYNC_FULL = 1;
+export class LspServer {
+    #root;
+    #options;
+    #open = new Map();
+    #published = new Set();
+    #running = false;
+    #again = false;
+    #shutdownRequested = false;
+    #exited = false;
+    constructor(options) {
+        this.#options = options;
+        this.#root = options.root;
+    }
+    get exited() {
+        return this.#exited;
+    }
+    get exitCode() {
+        return this.#shutdownRequested ? 0 : 1;
+    }
+    async handle(message) {
+        if (message.method === undefined)
+            return;
+        switch (message.method) {
+            case 'initialize':
+                this.#root = rootIn(message.params) ?? this.#root;
+                this.#reply(message.id, {
+                    capabilities: {
+                        textDocumentSync: { openClose: true, change: SYNC_FULL, save: true },
+                        diagnosticProvider: {
+                            identifier: SOURCE_NAME,
+                            interFileDependencies: true,
+                            workspaceDiagnostics: false,
+                        },
+                    },
+                    serverInfo: { name: named('integrity') },
+                });
+                return;
+            case 'initialized':
+                return;
+            case 'shutdown':
+                this.#shutdownRequested = true;
+                this.#reply(message.id, null);
+                return;
+            case 'exit':
+                this.#exited = true;
+                return;
+            case 'textDocument/didOpen': {
+                const params = message.params;
+                const path = this.#pathOf(params?.textDocument?.uri);
+                if (path === undefined)
+                    return;
+                this.#open.set(path, typeof params?.textDocument?.text === 'string' ? params.textDocument.text : '');
+                await this.#recompute();
+                return;
+            }
+            case 'textDocument/didChange': {
+                const params = message.params;
+                const path = this.#pathOf(params?.textDocument?.uri);
+                if (path === undefined)
+                    return;
+                const latest = params?.contentChanges?.at(-1)?.text;
+                if (typeof latest === 'string')
+                    this.#open.set(path, latest);
+                await this.#recompute();
+                return;
+            }
+            case 'textDocument/didSave':
+                await this.#recompute();
+                return;
+            case 'textDocument/didClose': {
+                const path = this.#pathOf(message.params?.textDocument?.uri);
+                if (path === undefined)
+                    return;
+                this.#open.delete(path);
+                await this.#recompute();
+                return;
+            }
+            case 'textDocument/diagnostic': {
+                const path = this.#pathOf(message.params?.textDocument?.uri);
+                const computed = await report(this.#sourceForRoot(), this.#open, this.#published);
+                this.#published = new Set([...computed].filter(([, list]) => list.length > 0).map(([file]) => file));
+                this.#reply(message.id, {
+                    kind: 'full',
+                    items: path === undefined ? [] : (computed.get(path) ?? []),
+                });
+                return;
+            }
+            default:
+                if (message.id !== undefined && message.id !== null) {
+                    this.#options.send({
+                        jsonrpc: '2.0',
+                        id: message.id,
+                        error: { code: METHOD_NOT_FOUND, message: `${message.method} is not implemented by ${SOURCE_NAME}` },
+                    });
+                }
+        }
+    }
+    #sourceForRoot() {
+        return this.#options.sourceFor(this.#root);
+    }
+    #reply(id, result) {
+        if (id === undefined || id === null)
+            return;
+        this.#options.send({ jsonrpc: '2.0', id, result });
+    }
+    async #recompute() {
+        if (this.#running) {
+            this.#again = true;
+            return;
+        }
+        this.#running = true;
+        try {
+            do {
+                this.#again = false;
+                await (this.#options.settle?.() ?? sleep(200));
+                const computed = await report(this.#sourceForRoot(), this.#open, this.#published);
+                const nonEmpty = new Set();
+                for (const [path, diagnostics] of computed) {
+                    this.#publish(path, diagnostics);
+                    if (diagnostics.length > 0)
+                        nonEmpty.add(path);
+                }
+                this.#published = nonEmpty;
+            } while (this.#again);
+        }
+        finally {
+            this.#running = false;
+        }
+    }
+    #publish(path, diagnostics) {
+        this.#options.send({
+            jsonrpc: '2.0',
+            method: 'textDocument/publishDiagnostics',
+            params: { uri: pathToFileURL(resolve(this.#root, path)).href, diagnostics },
+        });
+    }
+    #pathOf(uri) {
+        if (typeof uri !== 'string' || !uri.startsWith('file://'))
+            return undefined;
+        let absolute;
+        try {
+            absolute = fileURLToPath(uri);
+        }
+        catch {
+            return undefined;
+        }
+        const path = relativeTo(this.#root, absolute).split('\\').join('/');
+        return path.startsWith('..') || path.startsWith('/') ? undefined : path;
+    }
+}
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+function rootIn(params) {
+    const folder = params?.workspaceFolders?.[0]?.uri;
+    for (const uri of [folder, params?.rootUri]) {
+        if (typeof uri !== 'string' || !uri.startsWith('file://'))
+            continue;
+        try {
+            return fileURLToPath(uri);
+        }
+        catch {
+            continue;
+        }
+    }
+    return typeof params?.rootPath === 'string' ? params.rootPath : undefined;
+}

package/dist/integrity/sealed.d.ts

@@ -0,0 +1 @@
+export declare const SEALED: Readonly<Record<string, string>>;

package/dist/integrity/sealed.js

@@ -0,0 +1,56 @@
+export const SEALED = {
+    'attach.js': 'e879e49449a3b90118335ab4d2ea6666956da92203438fac7b88ff3a65a79103',
+    'check-threads.js': '1754d3acf4e5ea45ce11bf62b1404d59fa027eb22450e253e303acd13f75f6d8',
+    'constraint.js': 'c6eebad19fc11c42c095d82f5658c204f322d136bcbaab98aa9fc06dfa625afb',
+    'generators/compiler.js': 'c6db73bfd31513d8334ef5cd063fb5f12b89c56739ff0f2b73249252d1817cdc',
+    'generators/gate.js': 'f865f469f13b9e3b2eb120bd233b3e286c0df30a4cdf15cd20be4cb995854f88',
+    'generators/issues.js': '21cd7349d3375f15cb8b1a0c31714ab645b021b952275046b56357fba68478b8',
+    'generators/publish.js': 'dcbeaf744dd786e8a606fa9d79fb4d3e3cfa6ae1a1432261547f1e4ef186b81e',
+    'generators/rule.js': '82bdfefbf394528fa4e7994a60eb423b3188277571937e161648f72666728aa4',
+    'generators/seal.js': '39fb8ab5c95b9c0fd1d3d38090785b2e1890653bb1d0454868426b67b28abe3a',
+    'generators/trial.js': 'a2ef8fda83bb2894ae088a0d7887a4e49b9693fa1a7e1345879aaa63041914b0',
+    'lint.js': '63f9957725a94498d7e5a49544da343c5f2e1b3b9c2778000dae4a4f39036ef9',
+    'lsp/bin.js': 'b71d5da40c137dbe87083ad29bf1a54e30a190113b8811602263f4c5a4d5a11c',
+    'lsp/diagnostics.js': '0fd15477b4df60e5ec065bb1a85c5daab6b9b433e730cb836b8ddc747554e0b9',
+    'lsp/findings.js': '72f7d80645c0941926a1cc029417fed93eca87e7d53bf2d032f4ef647fb1f168',
+    'lsp/lint.js': '159b07ffa100a62b2cd445d621606ae0d6b68aacc342cb5fdb3a2f4cadd7f508',
+    'lsp/protocol.js': 'd0ad8650307bf563bd058dc2bbbbc0ec9d4fd6dc2c9120bdc261d57c076ddc5d',
+    'lsp/server.js': 'a9f76280e395a47521973a14f3769c4df9e8c1153d29dedc535f56276e5a2e2e',
+    'slopnator.js': '804adba20c269c1134fd09e075d354db73b79cfd00c4b4ce66c1e40279670905',
+    'slopnators/sl_broken_lineage.js': '6d0ee15127166d9792b365e8a4623b5770a57e2ff92c2accf196afbb85052112',
+    'slopnators/sl_declared_elsewhere.js': '394da91ac84369217b4a02bc078ab98f62bf6d522042d84bec82b9705d621751',
+    'slopnators/sl_derived_drift.js': 'f7fb0e26cd6bff9dfe7392e1b1593a51741a6f6fac408bdafbb783e04141cf2f',
+    'slopnators/sl_hardcoded_style.js': 'a2b006990bc33150733645f3c17942ff497e7b3a6565af1331263df36d3b5e0a',
+    'slopnators/sl_inert_island.js': '0900de73ab7439b02a3321a6459e53882cfba6267dc8ef45d630ebe40f4bfa84',
+    'slopnators/sl_inert_slopnator.js': 'e3c35cfa2b094e1e2fd6824b75138cf44e8edb5ec396375d67e47897d84c45d7',
+    'slopnators/sl_missing_row.js': 'd942940388a873bebeff72d93cdb5fef20ba88e4fe29c1aa68e2f42389714a4a',
+    'slopnators/sl_no_barrel.js': '7df2a763d4b4ab16d945341b844271380b25774491bfa9c204dc252910951bc6',
+    'slopnators/sl_no_child_process.js': '24d4f89a1493c95db12e92a34dc4281a422226f638a47c795f26447090e056a1',
+    'slopnators/sl_no_comment.js': '4c4b9b502d6b33ed00d653d0b190d8f95b02bc5ef10da87f97913ca425f59f40',
+    'slopnators/sl_no_dispatch_bypass.js': '1def29fca350861b7185129180edd4727199e0f2bba92a0e0a8c0af437cbb382',
+    'slopnators/sl_no_import_cycle.js': '7ab70e4c182e88f73b4af75cddef9655a49996b8c70fcc2dcebd5f4aeb5fef92',
+    'slopnators/sl_no_such_command.js': 'fe037c2ad6891fd3c0338dd84c7007110c0bcd272a12bd8f1cb85ec779df7a8b',
+    'slopnators/sl_only_takes_a_literal.js': '3d5074f9c6a9bb581c80af8aa6d4a6793e29ac93c793367a67326acc1612c8fe',
+    'slopnators/sl_secret_literal.js': 'bc3987627f3b2892eec169d775771b6309d47b2c93e98c1bccad3f3ed5c5d2b6',
+    'slopnators/sl_stale_path.js': '3cc4050cb9ca2875afbb69c818d20d06e82f36a762ec48bd033c342a7023ff8a',
+    'slopnators/sl_twice_meant.js': '6fc5aaf29b635335bd4963931475e7334110439f8305737786c01be39f81230c',
+    'slopnators/sl_twice_parented.js': 'caa590bc4c11dbebe971f5a611a1712a529cc5a2900f37ba43cfa6b67a0a722b',
+    'slopnators/sl_undeclared_crossing.js': '47e41a38334a4b5a3eb0616d675dc46c5e4d6ce1138710b4470acc276e6ddec5',
+    'slopnators/sl_undeclared_destination.js': '3bbf07029a31eb31fa6556b686d067aae0cd5bf9487fe6ca1896984a55970a5c',
+    'slopnators/sl_undeclared_element.js': '2aa469ffdd58f104936904cbee2c95cb38182a2ac1057e0caa4db3d85e81331c',
+    'slopnators/sl_undeclared_node.js': '84c069a7d1bdec3d3c950ad40e016c129f280796b63a196a7866232e14995443',
+    'slopnators/sl_undeclared_operation.js': 'bc3fa4efc83bf5641020373d0f1506856c6272c3d59e4c4d261e3076f69a155e',
+    'slopnators/sl_undeclared_variant.js': 'e41ec11c9f4baf52dbea1aa7828238e5738de609ea47cdcac793cbe6198df770',
+    'slopnators/sl_undescribed.js': '15c6139a4afc3a4dc1a6196ec1acc2af5066a3330343074f6e2b321291cdbbd0',
+    'slopnators/sl_ungoverned_island.js': '555ae51adf994c5fce4ce51701af7d022be8824c001eeb132403fd6342a12a49',
+    'slopnators/sl_unkept_rows.js': '8abd67e8b8347a6dd9abd20fb7719d4f10553d6f329001a34ccc3e063d448e1d',
+    'slopnators/sl_unnamed_island.js': '0c92c5b6fdf59fb97448f24d72b883cd64317c23280316e043f993e7b75ac1da',
+    'slopnators/sl_unpaired_member.js': 'aafba4f829ef038289176b6e5ea6622494eba1982268d8d52b44f8c9889943e9',
+    'slopnators/sl_unpaired_slopnator.js': '2fa5b8c3c8b6a8a71466086f1d3ae32ea16fd22c49b113225e3c9a7e76eda45e',
+    'slopnators/sl_unprefixed_member.js': '67640331089c55ac59e7950e3c919144740309fb4a91cf0af87c41edb761f75d',
+    'slopnators/sl_unseamed_reach.js': 'd27a64c85b221e7c5bac99ab9d36955ad4945520d2b9e5ec75927574ca454cda',
+    'slopnators/sl_unthreaded.js': 'b686212f3515eb2769030979f7141d236677c9f3c1802e436f254ea5410a2361',
+    'slopnators/sl_untranslated_key.js': '224e80a4f34ce760502ee256347c9191e8d103e8b0ff58ef995c10111ddf2854',
+    'slopnators/sl_unversioned.js': 'df73b3186e42e6b58e7fb3fd48c3146a2d3902a337861a6ccb52f433a569e392',
+    'sweep.js': '2402ba042f87e693bf785d8e81b40870dd2fec539a70a9593d7ecba767dcda2c',
+};

package/dist/integrity/slopnator.d.ts

@@ -0,0 +1,90 @@
+import { type Constraint } from './constraint.ts';
+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;
+    readonly ancestors: () => readonly unknown[];
+    readonly comments: () => readonly Spoken[];
+}
+export interface Spoken {
+    readonly value: string;
+    readonly range: readonly [number, number];
+}
+export interface Proves {
+    readonly wrong: readonly Proof[];
+    readonly right: readonly Proof[];
+}
+export interface Reads {
+    readonly holds: (node: unknown, at: SlopnatorContext) => boolean | string | typeof NOT_WRITTEN;
+    readonly fixes?: (node: unknown, at: SlopnatorContext) => string | undefined;
+    readonly proves: Proves;
+}
+export interface Reading extends Reads {
+    readonly on?: readonly string[];
+}
+export interface Running {
+    readonly checks: (root: string) => readonly string[];
+    readonly proves: Proves;
+}
+export type Slopnator = Reading | Running;
+export type Visiting = Reading & {
+    readonly on: readonly string[];
+};
+export declare const reads: (one: Slopnator) => one is Reading;
+export declare const visits: (one: Slopnator) => one is Visiting;
+export declare const sweeps: (one: Slopnator) => one is Reading;
+export interface Sourced {
+    readonly at: string;
+    readonly source: string;
+}
+export type Proof = string | {
+    readonly files: readonly Sourced[];
+    readonly at: string;
+};
+export interface Byproduct {
+    readonly path: string;
+    readonly content: string;
+}
+export declare function slopnatorName(rule: string): string;
+export declare function names(fragment: string, path: readonly string[]): boolean;
+export declare function governs(rule: Constraint, filename: string): boolean;
+export declare class UnloadableSlopnatorError extends Error {
+    constructor(rule: string, at: string, because: string);
+}
+export declare class UnreadableRulesError extends Error {
+    constructor(at: string, because: string);
+}
+export declare class BrokenSealError extends Error {
+    constructor(at: string, why: string);
+}
+export declare function unsealed(home?: string): readonly string[];
+export declare function verify(): void;
+export declare function load(root: string, all: readonly Constraint[]): Promise<ReadonlyMap<string, Slopnator>>;
+export declare function proofsOf(rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): {
+    readonly wrong: readonly Proof[];
+    readonly right: readonly Proof[];
+};
+export declare function scaffold(): string;
+export declare function write(root: string, byproduct: Byproduct): void;
+export declare function onDisk(root: string): readonly string[];
+export declare function named(all: readonly Constraint[]): readonly string[];
+export declare function rules(): Promise<readonly Constraint[] | undefined>;
+export declare function seeds(root: string, all: readonly Constraint[]): readonly Byproduct[];
+export declare const GENERALLY = "The check the rule beside it refuses with. The rule says what is banned and this finds it, reading every file that rule governs and answering whether each one breaks it.";
+export declare function declaring(at: string, says: string): string;
+export declare function declareSeeded(root: string, ids: readonly string[], says?: string): Promise<readonly string[]>;

package/dist/integrity/slopnator.js

@@ -0,0 +1,267 @@
+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 { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, sep } 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 { SEALED } from "./sealed.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));
+const BUILT = dirname(dirname(HOME));
+export const SHIPPED = `${HOME}/slopnators`;
+export const SEEDED = `${findTree().name}/slopnators`;
+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;
+export function slopnatorName(rule) {
+    return `sl_${rule
+        .replace(/[^a-zA-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase()}`;
+}
+const CANONICAL_TREE = 'threads';
+const TREE = findTree().name;
+function parts(one) {
+    return one.split('\\').join('/').split('/').filter((part) => part !== '');
+}
+function wanted(fragment) {
+    const all = parts(fragment);
+    return all[0] === CANONICAL_TREE ? [TREE, ...all.slice(1)] : all;
+}
+export function names(fragment, path) {
+    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 false;
+}
+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)))
+        return false;
+    return rule.where.paths.some((fragment) => names(fragment, path));
+}
+export class UnloadableSlopnatorError extends Error {
+    constructor(rule, at, because) {
+        super(`rule "${rule}" names a slopnator at ${at}, the file is on disk, and loading it threw: ${because}. ` +
+            'A slopnated that cannot be imported reads from every caller exactly like a slopnator that found nothing — ' +
+            'the sweep skips it, the trial falls through, and the rule reports green while enforcing nothing. ' +
+            'Fix the import, or delete the rule.');
+        this.name = 'UnloadableSlopnatorError';
+    }
+}
+export class UnreadableRulesError extends Error {
+    constructor(at, because) {
+        super(`${at} is where this tree states the rules it authors, and reading it threw: ${because}. ` +
+            'A tree whose rules cannot be read reports exactly like a tree that declared none — every surface runs, finds nothing of its own, and exits 0. ' +
+            'Fix the file, or delete it if this tree authors no rules of its own.');
+        this.name = 'UnreadableRulesError';
+    }
+}
+export class BrokenSealError extends Error {
+    constructor(at, why) {
+        super(`${at} ${why} — this package is not the one that was published, so nothing it refuses or allows can be trusted. ` +
+            'Reinstall it (`pnpm install --frozen-lockfile` re-verifies the published bytes), or if you meant to change it, run `thread seal` and publish that.');
+        this.name = 'BrokenSealError';
+    }
+}
+const INSTALLED = HOME.includes(`${sep}node_modules${sep}`);
+export function unsealed(home = HOME) {
+    const broken = [];
+    for (const [at, hash] of Object.entries(SEALED)) {
+        let held;
+        try {
+            held = readFileSync(join(home, at));
+        }
+        catch {
+            broken.push(`${at} is missing`);
+            continue;
+        }
+        if (createHash('sha256').update(held).digest('hex') !== hash)
+            broken.push(`${at} differs from the seal`);
+    }
+    return broken;
+}
+export function verify() {
+    if (!INSTALLED)
+        return;
+    const broken = unsealed(BUILT);
+    const first = broken[0];
+    if (first !== undefined)
+        throw new BrokenSealError(first.split(' ')[0] ?? '', first.split(' ').slice(1).join(' '));
+}
+export async function load(root, all) {
+    verify();
+    const found = new Map();
+    for (const rule of all) {
+        const name = slopnatorName(rule.id);
+        const at = homes(root)
+            .flatMap((dir) => [join(dir, `${name}.ts`), join(dir, `${name}.js`)])
+            .find((one) => existsSync(one));
+        if (at === undefined)
+            continue;
+        let module;
+        try {
+            module = await import(__rewriteRelativeImportExtension(pathToFileURL(at).href));
+        }
+        catch (thrown) {
+            throw new UnloadableSlopnatorError(rule.id, at, thrown instanceof Error ? thrown.message : String(thrown));
+        }
+        const one = module.slopnator;
+        if (one === undefined) {
+            throw new UnloadableSlopnatorError(rule.id, at, 'it exports no `slopnator`');
+        }
+        found.set(name, one);
+    }
+    return found;
+}
+export function proofsOf(rule, slopnators) {
+    const slopnated = slopnators.get(slopnatorName(rule.id))?.proves;
+    return { wrong: [rule.wrong, ...(slopnated?.wrong ?? [])], right: [rule.right, ...(slopnated?.right ?? [])] };
+}
+export function scaffold() {
+    return `import { NOT_WRITTEN, type Slopnator } from './slopnator.ts'
+
+export const slopnator: Slopnator = {
+  on: [],
+  holds: () => NOT_WRITTEN,
+  proves: { wrong: [], right: [] },
+}
+`;
+}
+export function write(root, byproduct) {
+    const path = join(root, byproduct.path);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, byproduct.content, 'utf8');
+}
+export function onDisk(root) {
+    const found = new Set();
+    for (const dir of homes(root)) {
+        if (!existsSync(dir))
+            continue;
+        for (const file of readdirSync(dir)) {
+            if (file.startsWith('sl_') && file.endsWith('.ts'))
+                found.add(file.replace(/\.ts$/, ''));
+        }
+    }
+    return [...found].sort();
+}
+export function named(all) {
+    return all.map((rule) => slopnatorName(rule.id)).sort();
+}
+export async function rules() {
+    const at = inTree(findTree(), 'rules.ts');
+    if (!existsSync(at))
+        return undefined;
+    let module;
+    try {
+        module = (await import(__rewriteRelativeImportExtension(pathToFileURL(at).href)));
+    }
+    catch (thrown) {
+        throw new UnreadableRulesError(at, thrown instanceof Error ? thrown.message : String(thrown));
+    }
+    if (module.RULES === undefined)
+        throw new UnreadableRulesError(at, 'it exports no `RULES`');
+    return module.RULES;
+}
+export function seeds(root, all) {
+    const found = onDisk(root);
+    return named(all)
+        .filter((wanted) => !found.includes(wanted))
+        .map((wanted) => ({ path: `${SEEDED}/${wanted}.ts`, content: scaffold() }));
+}
+export const GENERALLY = 'The check the rule beside it refuses with. The rule says what is banned and this finds it, reading every file that rule governs and answering whether each one breaks it.';
+export function declaring(at, says) {
+    return [
+        '      {',
+        "        id: 'slopnator',",
+        `        at: '${at}',`,
+        `        describes: ${quoted(says)},`,
+        '      },',
+    ].join('\n');
+}
+export async function declareSeeded(root, ids, says) {
+    if (ids.length === 0)
+        return [];
+    const at = inTree(findTree(), 'rules.ts');
+    let text;
+    try {
+        text = readFileSync(at, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const where = listBounds(text, 'RULES');
+    if (where === undefined)
+        return [];
+    const done = [];
+    for (const id of ids) {
+        const next = withSeed(text, listBounds(text, 'RULES') ?? where, id, declaring(`${SEEDED}/${slopnatorName(id)}.ts`, says ?? GENERALLY));
+        if (next === text)
+            continue;
+        text = next;
+        done.push(id);
+    }
+    if (done.length > 0)
+        writeFileSync(at, text, 'utf8');
+    return done;
+}
+if (invoked(import.meta.url)) {
+    const own = (await rules()) ?? [];
+    const seeded = seeds(ROOT, own);
+    for (const byproduct of seeded) {
+        write(ROOT, byproduct);
+        console.log(`slopnator: seeded ${byproduct.path}`);
+    }
+    const held = new Set(onDisk(ROOT));
+    const declared = await declareSeeded(ROOT, own.filter((rule) => held.has(slopnatorName(rule.id))).map((rule) => rule.id));
+    for (const id of declared)
+        console.log(`slopnator: declared the slopnator for "${id}" in its own row`);
+    console.log(`slopnator: ${String(own.length)} rule(s), ${String(seeded.length)} seeded, ${String(declared.length)} declared. ` +
+        `${String(CONSTRAINTS.length)} shipped constraint(s) are authored, not seeded — unpaired-slopnator refuses one whose slopnated is missing.`);
+}

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

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

package/dist/integrity/slopnators/sl_broken_lineage.js

@@ -0,0 +1,35 @@
+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) => {
+        const path = here(at.filename);
+        if (path === THREAD_AT)
+            return false;
+        if (unreadable(path, at.text) !== undefined)
+            return false;
+        const children = names(path, at.text);
+        if (children.length === 0)
+            return false;
+        if (threaded().has(path))
+            return false;
+        return `this file names ${String(children.length)} child(ren) — ${children.slice(0, 3).join(', ')} — and its own origin does not trace back to threads/, so everything it parents is stranded with it`;
+    },
+    proves: {
+        wrong: [
+            "export const M: Threaded = {\n  declares: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
+            "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}",
+        ],
+        right: [
+            {
+                files: [
+                    { at: 'threads/_names_it.ts', source: "export const OWNER: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_mid.ts',\n    },\n  ],\n}\n" },
+                    { at: 'scripts/_probe_mid.ts', source: "export const MID: Threaded = {\n  declares: [\n    {\n      at: 'scripts/_probe_end.ts',\n    },\n  ],\n}\n" },
+                    { at: 'scripts/_probe_end.ts', source: 'export const END = 1\n' },
+                ],
+                at: 'scripts/_probe_mid.ts',
+            },
+            'export const PLAIN = 1',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_declared_elsewhere.js

@@ -0,0 +1,33 @@
+import { filesGoverned, here, islandsDeclared } from "./sl_unthreaded.js";
+const sentence = (describes) => `${describes.split(/ — |\. /)[0] ?? describes}.`;
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        for (const island of islandsDeclared()) {
+            if (island.define === undefined)
+                continue;
+            const call = new RegExp(`(?<!function\\s)\\b${island.define}\\s*\\(`);
+            if (!call.test(at.text))
+                continue;
+            const places = filesGoverned(island.governs);
+            if (places.includes(path))
+                continue;
+            const where = places.length === 0 ? 'nowhere — its kind is derived, never authored' : places.join(' or ');
+            return (`\`${island.define}\` is called here and the "${island.id}" island governs ${where}, so the loader never opens this ` +
+                `file for it and the declaration produces nothing. ${sentence(island.describes)}`);
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "export default defineEvents({ specVersion: 1, events: [] })",
+            "export default definePermissions({ specVersion: 1, entities: [] })",
+            "export default defineMap({ specVersion: 1, screens: [] })",
+        ],
+        right: [
+            "import events from 'app/_declare/events'",
+            "import permissions from 'app/_declare/permissions'",
+            'const screens = useRead(recentScreens)',
+        ],
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { Slopnator } from '../slopnator.ts';
+export interface Derivation {
+    readonly at: string;
+    readonly by?: string;
+    readonly runs?: string;
+}
+export declare function derivations(root: string): readonly Derivation[];
+export declare const slopnator: Slopnator;