@prestack/thread 0.0.1

package/dist/integrity/slopnators/sl_derived_drift.js

@@ -0,0 +1,91 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+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 = [];
+    for (const at of reached()) {
+        let text;
+        try {
+            text = readFileSync(resolve(root, at), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const threadedDerives = new Set(atsIn(text, new Set(['derives'])));
+        for (const opens of text.matchAll(/^\s*derives:\s*\[/gm)) {
+            const from = opens.index ?? 0;
+            let depth = 1;
+            let cursor = from + opens[0].length;
+            while (cursor < text.length && depth > 0) {
+                const one = text[cursor];
+                if (one === '[')
+                    depth += 1;
+                else if (one === ']')
+                    depth -= 1;
+                cursor += 1;
+            }
+            const own = [];
+            let nesting = 0;
+            for (const line of text.slice(from, cursor).split('\n')) {
+                if (nesting === 1)
+                    own.push(line);
+                for (const one of line) {
+                    if (one === '[')
+                        nesting += 1;
+                    else if (one === ']')
+                        nesting -= 1;
+                }
+            }
+            const block = own.join('\n');
+            for (const row of block.split(/^\s*\{$/m)) {
+                const at = /^\s*at:\s*'([^']+)'/m.exec(row)?.[1];
+                const by = /^\s*by:\s*'([^']+)'/m.exec(row)?.[1];
+                const runs = /^\s*runs:\s*'([^']+)'/m.exec(row)?.[1];
+                if (at !== undefined && threadedDerives.has(at))
+                    found.push({ at, by, runs });
+            }
+        }
+    }
+    return found;
+}
+export const slopnator = {
+    checks: (root) => {
+        const findings = [];
+        const all = derivations(root);
+        const complete = all.filter((one) => one.by !== undefined && one.runs !== undefined);
+        const covered = new Set(complete.map((one) => one.at));
+        for (const at of new Set(all.map((one) => one.at))) {
+            if (covered.has(at))
+                continue;
+            findings.push(`${at} sits in a \`derives\` list and no row naming it states both \`by\` and \`runs\` — a byproduct nothing can re-run is a claim, and this check used to drop such a row in silence`);
+        }
+        return findings;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm no-such-check',\n    },\n  ],\n}\n" },
+                ],
+                at: 'threads/_drift_probe.ts',
+            },
+            {
+                files: [
+                    { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/finding.ts',\n    },\n  ],\n}\n" },
+                ],
+                at: 'threads/_drift_probe.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    { at: 'threads/_drift_probe.ts', source: "export const M: Threaded = {\n  derives: [\n    {\n      at: 'scripts/_generated/gate.mjs',\n      by: 'pnpm gate:generate',\n      runs: 'pnpm gate:check',\n    },\n  ],\n}\n" },
+                ],
+                at: 'threads/_drift_probe.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_hardcoded_style.js

@@ -0,0 +1,46 @@
+import ts from 'typescript';
+const ALONE = /^\s*([a-z][a-z0-9]*(?:-[a-z0-9]+)*)\s*:\s*([^;{}\n]+);\s*$/;
+const NAMED = /var\(\s*--/;
+const PIECES = new Set([
+    ts.SyntaxKind.StringLiteral,
+    ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+    ts.SyntaxKind.TemplateHead,
+    ts.SyntaxKind.TemplateMiddle,
+    ts.SyntaxKind.TemplateTail,
+]);
+export const slopnator = {
+    holds: (_node, at) => {
+        const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.JSX, at.text);
+        let token = scanner.scan();
+        while (token !== ts.SyntaxKind.EndOfFileToken) {
+            if (PIECES.has(token)) {
+                const said = scanner.getTokenValue();
+                const found = ALONE.exec(said);
+                if (found !== null) {
+                    const property = found[1] ?? '';
+                    const value = (found[2] ?? '').trim();
+                    if (value !== '' && !NAMED.test(value)) {
+                        return (`\`${property}\` is written into the compiler with \`${value}\` typed into it, so a ` +
+                            'stylesheet carries a decision nothing declared — no rebrand moves it, no mode or theme reaches it, and no sheet knows it is there');
+                    }
+                }
+            }
+            token = scanner.scan();
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "lines.push('  body {', '    background: #f8fbfa;', '  }')",
+            "classes.push('    padding: 8px 16px;')",
+            "return ['  :where(*) {', '    text-box-trim: trim-both;', '  }']",
+            "held.push('    color-scheme: light dark;')",
+        ],
+        right: [
+            "lines.push('  body {', '    background: var(--colour-page);', '  }')",
+            'lines.push(...block(selector, made, indent))',
+            'held.push(`    ${nameOf(id)}: ${made[id] ?? String()};`)',
+            'const held: readonly string[] = [];',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_inert_island.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { declaresIsland, here, rowsIn } from "./sl_unthreaded.js";
+import { findTree } from "../../core/tree.js";
+const ROOT = findTree().at;
+const TREE = `${findTree().name}/`;
+function schemaAt(at) {
+    const path = resolve(ROOT, at);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return declaresIsland(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (!path.startsWith(TREE))
+            return false;
+        let rows;
+        try {
+            rows = rowsIn(at.text);
+        }
+        catch {
+            return 'this file cannot be parsed, so the islands it declares were never read and nothing about what they govern was measured';
+        }
+        for (const row of rows) {
+            if (row.at === undefined || row.id === undefined)
+                continue;
+            const schema = schemaAt(row.at);
+            if (schema === undefined)
+                continue;
+            if ((row.governs ?? []).length > 0)
+                continue;
+            return (`island "${row.id}" states nothing it governs, so ${schema}IslandSchema is a shape nothing is held to — ` +
+                'no file is the place its kind is declared, which makes every file the place, and the island is inert');
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'threads/_inert_probe.ts',
+                        source: "export const M: Islanding = {\n  declares: [\n    { id: 'entities', at: 'packages/core/spec/src/islands/entities.ts' },\n  ],\n}\n",
+                    },
+                ],
+                at: 'threads/_inert_probe.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'threads/_inert_probe.ts',
+                        source: "export const M: Islanding = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: [] },\n  ],\n}\n",
+                    },
+                ],
+                at: 'threads/_inert_probe.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'threads/_inert_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/_inert_probe.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'threads/_inert_probe.ts',
+                        source: "export const M: Threaded = {\n  declares: [\n    { id: 'a-file', at: 'threads/thread.ts' },\n  ],\n}\n",
+                    },
+                ],
+                at: 'threads/_inert_probe.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_inert_slopnator.js

@@ -0,0 +1,76 @@
+const keyOf = (node) => node.key?.name ?? (typeof node.key?.value === 'string' ? node.key.value : undefined);
+const answersUnwritten = (held) => {
+    const fn = held;
+    if (fn?.type !== 'ArrowFunctionExpression')
+        return false;
+    return fn.body?.type === 'Identifier' && fn.body.name === 'NOT_WRITTEN';
+};
+const statesNothing = (held) => {
+    const proves = held;
+    if (proves?.type !== 'ObjectExpression')
+        return false;
+    return (proves.properties ?? []).some((one) => {
+        const key = keyOf(one);
+        if (key !== 'wrong' && key !== 'right')
+            return false;
+        const list = one.value;
+        return list?.type === 'ArrayExpression' && (list.elements ?? []).length === 0;
+    });
+};
+export const slopnator = {
+    on: ['Property'],
+    holds: (node) => {
+        const held = node;
+        const key = keyOf(held);
+        if (key === 'holds' && answersUnwritten(held.value)) {
+            return 'this is still the scaffold — it answers `NOT_WRITTEN` to everything, so the rule that names it registers, loads, reports nothing, and reads from outside exactly like a rule being obeyed';
+        }
+        if (key === 'on') {
+            const list = held.value;
+            if (list?.type === 'ArrayExpression' && (list.elements ?? []).length === 0) {
+                return 'it says it visits syntax and then names no node type, so it is handed nothing and governs nothing inside the files its rule governs';
+            }
+        }
+        if (key === 'proves' && statesNothing(held.value)) {
+            return 'its `proves` states nothing — with no form it refuses and none it accepts, no trial is derived from it, so nothing anywhere shows the slopnator does what its row claims';
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+                        source: 'export const slopnator = {\n  on: [],\n  holds: () => NOT_WRITTEN,\n  proves: { wrong: [], right: [] },\n}\n',
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+                        source: "export const slopnator = {\n  holds: (_node, at) => at.text.includes('nope') && 'found',\n  proves: { wrong: [], right: ['const held = 1'] },\n}\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+                        source: "export const slopnator = {\n  holds: (_node, at) => at.text.includes('nope') && 'found',\n  proves: { wrong: ['nope'], right: ['const held = 1'] },\n}\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+            },
+            {
+                files: [{ at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts', source: 'export const held = 1\n' }],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_inert.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_missing_row.js

@@ -0,0 +1,180 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { ORGANISATION, ours } from "../../core/scope.js";
+import { findTree } from "../../core/tree.js";
+/**
+ * A row the package still ships and the tree no longer holds.
+ *
+ * Read as TEXT, deliberately. Eight laws were once added whose walks imported a workspace package,
+ * plain Node could not resolve it, `load()` swallowed the failure, and all eight read from every
+ * caller exactly like laws finding nothing. Nothing here imports anything but node builtins.
+ */
+const ROOT = findTree().at;
+/** A node: a const annotated `Threaded`. */
+const NODE = /export\s+const\s+[A-Za-z_$][\w$]*\s*:\s*Threaded\b/;
+/**
+ * Where a node's rows are written.
+ *
+ * A node may open the list inline, or name a `declares` array declared beside it and reference it by
+ * shorthand. Only the first was read, so `@thread/ui`'s tokens and signals nodes — 107 of its 178
+ * shipped rows — reported as shipping nothing, and every one of them could be deleted in silence.
+ */
+const SHAPES = [/declares:\s*\[/g, /export\s+const\s+declares\b[^\n]*?=\s*\[/g];
+/**
+ * How a row states its id.
+ *
+ * A row may be an object literal, or a call to a factory declared beside the list that takes the id
+ * first. Only the literal was read, which is the other half of why tokens and signals were invisible.
+ */
+const ID = /\bid:\s*'([^']+)'/g;
+const CALLED = /(?:^|[\s,[(])[a-zA-Z_$][\w$]*\(\s*'([^']+)'/g;
+/** Strings out first, so a fixture that PRINTS a declaration is not read as being one. */
+const QUOTED = /"(?:[^"\\\n]|\\.)*"|`(?:[^`\\]|\\.)*`/g;
+function closes(code, from) {
+    let depth = 0;
+    for (let at = from; at < code.length; at += 1) {
+        if (code[at] === '[')
+            depth += 1;
+        else if (code[at] === ']') {
+            depth -= 1;
+            if (depth === 0)
+                return at;
+        }
+    }
+    return -1;
+}
+/**
+ * What a package SHIPS: only the ids inside a `declares` list.
+ *
+ * It was every id anywhere in a file that held one such list, which read an `Appending`'s own `id`
+ * as a shipped row — `@thread/operations` was reported as shipping `seed-generator`, the name of a
+ * row it asks an app to APPEND into another list, not one it declares.
+ */
+function shippedIn(text) {
+    const code = text.replace(QUOTED, '""');
+    if (!NODE.test(code))
+        return new Set();
+    const found = new Set();
+    for (const shape of SHAPES) {
+        for (const one of code.matchAll(shape)) {
+            const opens = (one.index ?? 0) + one[0].length - 1;
+            const shut = closes(code, opens);
+            if (shut === -1)
+                continue;
+            const rows = code.slice(opens, shut);
+            for (const held of rows.matchAll(ID))
+                found.add(held[1] ?? '');
+            for (const held of rows.matchAll(CALLED))
+                found.add(held[1] ?? '');
+        }
+    }
+    return found;
+}
+/**
+ * What a tree HOLDS: every id in it, whichever list it sits in.
+ *
+ * Gating this on `declares` made every row in `derivation.ts` invisible, because its node states no
+ * `declares` at all and its rows live in `GENERATORS`. A row plainly on disk read as missing, and
+ * running the command this law recommends would not have cleared the finding.
+ */
+function heldIn(text) {
+    const code = text.replace(QUOTED, '""');
+    const found = new Set();
+    for (const one of code.matchAll(ID))
+        found.add(one[1] ?? '');
+    for (const one of code.matchAll(CALLED))
+        found.add(one[1] ?? '');
+    return found;
+}
+function filesIn(dir) {
+    try {
+        return readdirSync(dir).filter((one) => one.endsWith('.ts')).map((one) => join(dir, one));
+    }
+    catch {
+        return [];
+    }
+}
+/** Every installed thread package that ships nodes of its own. */
+function installed() {
+    const at = join(ROOT, 'node_modules', ORGANISATION);
+    const found = [];
+    for (const one of safely(at)) {
+        const name = `${ORGANISATION}/${one}`;
+        if (!ours(name))
+            continue;
+        const src = join(at, one, 'dist');
+        if (existsSync(src) && statSync(src).isDirectory())
+            found.push({ name, src });
+    }
+    return found;
+}
+function safely(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function read(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export const slopnator = {
+    checks: () => {
+        const tree = findTree();
+        /* Every id the tree holds, across every node in it. */
+        const held = new Set();
+        for (const path of filesIn(tree.dir))
+            for (const one of heldIn(read(path)))
+                held.add(one);
+        /*
+         * Only packages this tree ATTACHED, not every one installed.
+         *
+         * Measured by running it: the first version named `@thread/knowledge`, which the audit app has
+         * in `node_modules` and never attached — so the law demanded rows for a package nobody had
+         * asked for. A package is attached when the tree names a file inside it; one nothing points at
+         * is a dependency, and a dependency ships nothing this tree promised to hold.
+         */
+        const wired = new Set();
+        for (const path of filesIn(tree.dir)) {
+            for (const one of read(path).matchAll(/node_modules\/(@[\w.-]+\/[\w.-]+)\//g))
+                wired.add(one[1] ?? '');
+        }
+        const found = [];
+        for (const pkg of installed()) {
+            if (!wired.has(pkg.name))
+                continue;
+            for (const path of filesIn(pkg.src)) {
+                const shipped = shippedIn(read(path));
+                if (shipped.size === 0)
+                    continue;
+                for (const id of [...shipped].sort()) {
+                    /* The node's own id names the list, not a row in it. */
+                    if (held.has(id))
+                        continue;
+                    found.push(`${pkg.name} ships \`${id}\` and this tree does not hold it — run \`thread attach ${pkg.name}\` to put it back`);
+                }
+            }
+        }
+        return found;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [{ at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../../core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [],\n}\n" }],
+                at: '_threads/_probe_missing.ts',
+            },
+        ],
+        right: [
+            {
+                files: [{ at: '_threads/_probe_missing.ts', source: "import type { Threaded } from '../../core/thread.ts'\n\nexport const M: Threaded = {\n  declares: [\n    {\n      id: 'colour',\n    },\n  ],\n}\n" }],
+                at: '_threads/_probe_missing.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_no_barrel.js

@@ -0,0 +1,41 @@
+import { here } from "./sl_unthreaded.js";
+const BARREL_NAME = /(^|\/)index\.(ts|tsx|mts|cts|js|mjs|cjs)$/;
+const CODE = /\.(ts|tsx|mts|cts|js|mjs|cjs)$/;
+const SAYS = "can't do barrels lazy ass";
+function reExportsOnly(text) {
+    const lines = text
+        .split('\n')
+        .map((one) => one.trim())
+        .filter((one) => one !== '');
+    if (lines.length === 0)
+        return false;
+    return lines.every((one) => one.startsWith('export *') || one.startsWith('export {') || one.startsWith('}') || one.startsWith('} from') || /^[A-Za-z_$][\w$]*,?$/.test(one) || /^type [A-Za-z_$][\w$]*,?$/.test(one));
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (!CODE.test(path))
+            return false;
+        if (BARREL_NAME.test(path)) {
+            return `${SAYS} — this file is named for the folder it sits in, so it exists to list what the folder holds, and the tree already says that`;
+        }
+        if (reExportsOnly(at.text)) {
+            return `${SAYS} — every line of this file is a re-export, so it holds no thing of its own and names nothing the tree has not already named`;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [{ at: 'packages/_probe_barrel/index.ts', source: "export const held = 1\n" }],
+                at: 'packages/_probe_barrel/index.ts',
+            },
+        ],
+        right: [
+            {
+                files: [{ at: 'packages/_probe_barrel/held.ts', source: "export const held = 1\n" }],
+                at: 'packages/_probe_barrel/held.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_no_child_process.js

@@ -0,0 +1,61 @@
+const STARTS_A_PROCESS = new Set(['node:child_process', 'child_process']);
+const named = (held) => {
+    const one = held;
+    return one?.type === 'Literal' && typeof one.value === 'string' ? one.value : undefined;
+};
+export const slopnator = {
+    on: ['ImportDeclaration', 'ImportExpression', 'CallExpression'],
+    holds: (node) => {
+        const held = node;
+        const from = held.type === 'ImportDeclaration' || held.type === 'ImportExpression'
+            ? (named(held.source) ?? named(held.arguments?.[0]))
+            : held.callee?.name === 'require'
+                ? named(held.arguments?.[0])
+                : undefined;
+        if (from === undefined || !STARTS_A_PROCESS.has(from))
+            return false;
+        return `it imports \`${from}\`, so this slopnator can start a process — and whatever it starts can reach back into the enforcement that called it`;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+                        source: "import { spawnSync } from 'node:child_process'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+                        source: "const held = await import('child_process')\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+                        source: "import { readFileSync } from 'node:fs'\nexport const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+            },
+            {
+                files: [
+                    {
+                        at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+                        source: "export const slopnator = { holds: () => false, proves: { wrong: ['a'], right: ['b'] } }\n",
+                    },
+                ],
+                at: 'packages/core/src/integrity/slopnators/sl_probe_spawn.ts',
+            },
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_no_comment.js

@@ -0,0 +1,41 @@
+const shebang = (text) => (text.startsWith('#!') ? text.slice(2, text.indexOf('\n')) : undefined);
+const spoken = (text, all) => {
+    const line = shebang(text);
+    return all.filter((one, index) => !(index === 0 && one.value === line));
+};
+export const slopnator = {
+    on: ['Program'],
+    holds: (_node, at) => {
+        const all = spoken(at.text, at.comments());
+        if (all.length === 0)
+            return false;
+        const first = (all[0]?.value ?? '')
+            .split('\n')
+            .map((line) => line.trim().replace(/^\*+\s?/, ''))
+            .find((line) => line !== '') ?? '';
+        return `${String(all.length)} comment(s), the first saying "${first.slice(0, 60)}"`;
+    },
+    fixes: (_node, at) => {
+        const all = spoken(at.text, at.comments());
+        if (all.length === 0)
+            return undefined;
+        let out = at.text;
+        for (const one of [...all].sort((a, b) => b.range[0] - a.range[0])) {
+            out = out.slice(0, one.range[0]) + out.slice(one.range[1]);
+        }
+        return out.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n');
+    },
+    proves: {
+        wrong: [
+            'const a = 1 // a line comment',
+            '/* a block comment */\nconst a = 1',
+            '/** JSDoc on the export */\nexport const a = 1',
+        ],
+        right: [
+            'const a = "// not a comment"',
+            'const url = "https://example.com/docs"',
+            'const a = 1',
+            '#!/usr/bin/env node\nconst a = 1',
+        ],
+    },
+};

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

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