@prestack/thread 0.0.1

package/dist/integrity/slopnators/sl_twice_meant.js

@@ -0,0 +1,30 @@
+import { here, index, meaningsIn, parses, unreadable } from "./sl_unthreaded.js";
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (unreadable(path, at.text) !== undefined)
+            return false;
+        const mine = parses(path) ? meaningsIn(at.text) : [];
+        if (mine.length === 0)
+            return false;
+        const meanings = index().meanings;
+        for (const one of mine) {
+            const held = meanings.get(one.id);
+            if (held === undefined || held.size < 2)
+                continue;
+            return `\`${one.id}\` is coined with ${String(held.size)} different \`describes\`, and the glossary holds one meaning per word`;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'A different thing entirely.',\n    },\n  ],\n}",
+            "const M: Threaded = {\n  declares: [\n    {\n      id: 'two',\n      describes: 'The stated meaning.',\n    },\n    {\n      id: 'two',\n    },\n  ],\n}",
+        ],
+        right: [
+            "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n  ],\n}",
+            "const M: Threaded = {\n  declares: [\n    {\n      id: 'one',\n      describes: 'The first thing.',\n    },\n    {\n      id: 'two',\n      describes: 'A different thing entirely.',\n    },\n  ],\n}",
+            'const M = { declares: [] }',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_twice_parented.js

@@ -0,0 +1,34 @@
+import { atsIn, here, index, parses, unreadable } from "./sl_unthreaded.js";
+const ONLY_DECLARES = new Set(['declares']);
+const declaredIn = (text) => atsIn(text, ONLY_DECLARES);
+export const slopnator = {
+    holds: (_node, at) => {
+        const path = here(at.filename);
+        if (unreadable(path, at.text) !== undefined)
+            return false;
+        const mine = parses(path) ? declaredIn(at.text) : [];
+        if (mine.length === 0)
+            return false;
+        const threaded = index().declared;
+        for (const claimed of mine) {
+            const times = threaded.get(claimed) ?? 0;
+            if (times > 1)
+                return `${claimed} is declared ${String(times)} times, and \`declares\` is exactly one parent ever`;
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/one.ts',\n    },\n  ],\n}",
+            "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/two.ts',\n    },\n    {\n      at: 'threads/three.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+            "const ROW = {\n  at: 'threads/one.ts',\n}\nconst M: Threaded = {\n  declares: [ROW, ROW],\n}",
+        ],
+        right: [
+            "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/two.ts',\n    },\n  ],\n}",
+            "const M: Threaded = {\n  derives: [\n    {\n      at: 'threads/one.ts',\n    },\n    {\n      at: 'threads/one.ts',\n    },\n  ],\n}",
+            'const M = { declares: [] }',
+            "const ROW = {\n  at: 'threads/one.ts',\n}\nconst M: Threaded = {\n  declares: [ROW],\n}",
+            "const M: Threaded = {\n  declares: [\n    {\n      at: 'threads/one.ts',\n      declares: [\n        {\n          at: 'threads/two.ts',\n        },\n      ],\n    },\n  ],\n}",
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_crossing.js

@@ -0,0 +1,78 @@
+import { descend, under } from "../../core/descend.js";
+import { here } from "./sl_unthreaded.js";
+const CROSSINGS = [
+    { what: 'the network', finds: /(?<![.\w])fetch\s*\(/ },
+    { what: 'the network', finds: /(?<![.\w])XMLHttpRequest\b/ },
+    { what: 'the clock', finds: /\bDate\s*\.\s*now\s*\(/ },
+    { what: 'the clock', finds: /\bperformance\s*\.\s*now\s*\(/ },
+    { what: 'the clock', finds: /\bsetInterval\s*\(/ },
+    { what: 'the clock', finds: /\bsetTimeout\s*\(/ },
+    { what: 'the clock', finds: /\brequestAnimationFrame\s*\(/ },
+    { what: 'randomness', finds: /\bMath\s*\.\s*random\s*\(/ },
+    { what: 'randomness', finds: /\bcrypto\s*\.\s*randomUUID\s*\(/ },
+    { what: 'the queue', finds: /\bqueue\s*\.\s*enqueue\s*\(/ },
+    { what: 'a seam', finds: /\b(?:files|llm|http)\s*\.\s*(?:call|run|complete|put|signedUrl|remove|get)\s*\(/ },
+];
+const OPERATIONS_ID = 'operations';
+const NODES_ID = 'nodes';
+let bodies;
+/*
+ * The files this law is about, read off the tree rather than off a path.
+ *
+ * A crossing belongs in a declared node and nowhere else, so what the law has to know is which
+ * files ARE declared nodes — every row in an operation's `seeds` that requires a node type. It
+ * cannot be a path rule: an operation seeds its node bodies and its input file into the same
+ * directory, so excepting the directory would except the input file too and leave a hole exactly
+ * one file wide per operation. Measured 2026-08-27: with the directory excepted instead, this law
+ * fired on `operations/wf_asks/asks_it.ts` — a node body calling the model its operation had
+ * declared, which is the one place the law's own `instead` sends you.
+ */
+function declared() {
+    if (bodies !== undefined)
+        return bodies;
+    const pass = descend();
+    const found = new Set();
+    for (const [at, threadings] of pass.threaded) {
+        for (const one of threadings) {
+            if (one.list !== 'seeds')
+                continue;
+            if (!under(pass, one.by, OPERATIONS_ID) || under(pass, one.by, NODES_ID))
+                continue;
+            if ((one.row.requires ?? []).length === 0)
+                continue;
+            found.add(at);
+        }
+    }
+    bodies = found;
+    return found;
+}
+export const slopnator = {
+    holds: (_node, at) => {
+        if (declared().has(here(at.filename)))
+            return false;
+        for (const crossing of CROSSINGS) {
+            if (!crossing.finds.test(at.text))
+                continue;
+            return (`${crossing.what} reached outside a declared node — nothing recorded this crossing, so it ` +
+                'cannot be replayed, retried, priced or unwound, and the page renders exactly the same either way');
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "const res = await fetch('https://api.stripe.com/v1/charges')",
+            'const at = Date.now()',
+            'const id = crypto.randomUUID()',
+            "await queue.enqueue('job', payload)",
+            "await files.put('receipt.pdf', bytes)",
+            'const t = setInterval(() => refetch(), 5000)',
+            'const t = setTimeout(function again() { refetch(); setTimeout(again, 5000) }, 5000)',
+            'window.requestAnimationFrame(step)',
+        ],
+        right: [
+            "const node = { id: 'st_charge', kind: 'action', action: 'payment.charge', declares: { seams: ['http'] } }",
+            'const rows = useRead(recentOrders)',
+            "const { data } = useRead(recentOrders, { refresh: 'every-5s' })",
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_destination.js

@@ -0,0 +1,56 @@
+const HREF = 'href';
+const GLOBALS = new Set(['window', 'globalThis', 'self']);
+const HISTORIES = new Set(['router', 'navigation', 'history']);
+const MOVES = new Set(['push', 'replace', 'prefetch']);
+const named = (held) => {
+    if (held?.type === 'Identifier' || held?.type === 'JSXIdentifier')
+        return typeof held.name === 'string' ? held.name : undefined;
+    if (held?.type === 'Literal' && typeof held.value === 'string')
+        return held.value;
+    return undefined;
+};
+const spoken = (held) => {
+    if (held.type === 'JSXAttribute')
+        return named(held.name);
+    if (held.type === 'Property')
+        return held.computed === true ? undefined : named(held.key);
+    return undefined;
+};
+function moving(held) {
+    if (held.type !== 'MemberExpression' || held.computed === true)
+        return undefined;
+    const on = named(held.object);
+    const reached = named(held.property);
+    if (on === undefined || reached === undefined)
+        return undefined;
+    if (GLOBALS.has(on) && reached === 'location')
+        return `${on}.location`;
+    if (HISTORIES.has(on) && MOVES.has(reached))
+        return `${on}.${reached}()`;
+    return undefined;
+}
+export const slopnator = {
+    on: ['JSXAttribute', 'Property', 'MemberExpression'],
+    holds: (node) => {
+        const held = node;
+        const written = spoken(held) === HREF ? '`href`' : moving(held);
+        if (written === undefined)
+            return false;
+        return (`${written} moves somebody without naming a screen, so the map holds no link for it — ` +
+            'the destination reads as unreachable to the orphan pass, the app reads as having no path to it, and it navigates correctly');
+    },
+    proves: {
+        wrong: [
+            "const link = { href: '/orders/42' }",
+            "window.location = '/orders/42'",
+            "router.push('/orders/42')",
+            'history.replace(next)',
+            'navigation.prefetch(next)',
+        ],
+        right: [
+            '<Link.label navigateTo="Home" labelKey="home.title" />',
+            "const to = { navigateTo: 'Order', labelKey: 'order.title' }",
+            'const rows = orders.push(one)',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_element.js

@@ -0,0 +1,34 @@
+const HOST = /^[a-z]/;
+function tagOf(node) {
+    const name = node?.name;
+    if (name?.type === 'JSXNamespacedName') {
+        const space = typeof name.namespace?.name === 'string' ? name.namespace.name : '';
+        const local = typeof name.name?.name === 'string' ? String(name.name.name) : '';
+        return `${space}:${local}`;
+    }
+    if (name?.type !== 'JSXIdentifier')
+        return undefined;
+    return typeof name.name === 'string' ? name.name : undefined;
+}
+export const slopnator = {
+    on: ['JSXOpeningElement'],
+    holds: (node) => {
+        const tag = tagOf(node);
+        if (tag === undefined || !HOST.test(tag))
+            return false;
+        return (`<${tag}> is a host element, so it wears no declared style, sits in no catalogue, and the style guide, ` +
+            'a rebrand and every overlay read past it — it renders and nothing downstream knows it is there');
+    },
+    proves: {
+        wrong: [
+            '<div className="row" />',
+            '<button onClick={save}>save</button>',
+            '<svg:path d="M0 0" />',
+        ],
+        right: [
+            '<Box.card />',
+            '<Column>{rows}</Column>',
+            '<Button.buttonPrimary label="save" />',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_node.js

@@ -0,0 +1,59 @@
+import { dirname, join, normalize } from 'node:path';
+import { here, index, parses, unreadable } from "./sl_unthreaded.js";
+/*
+ * Every string this file writes, whatever it writes it for.
+ *
+ * The first reading matched `node: '<name>'`, which was the shape when an operation named its node
+ * in a string beside a step of its own; a node builds its own span now, so that matched nothing on
+ * any real file. The second matched `import … from '<path>'`, which was the one route anybody had
+ * thought of — and a dynamic `import()`, a `require()` and an `export … from` each walked straight
+ * through it, measured on a real tree. Enumerating the ways in is how a refusal ends up as a list of
+ * whatever somebody happened to try. What matters is the path, not the syntax carrying it.
+ */
+const SAID = /'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"|`((?:[^`\\$]|\\.)*)`/g;
+const RELATIVE = /^\.\.?\//;
+const UNDER = 'nodes/';
+const slash = (one) => one.split('\\').join('/');
+function nodeAt(said, from) {
+    if (said === '')
+        return undefined;
+    const path = slash(normalize(RELATIVE.test(said) ? join(from, said) : said));
+    return path.startsWith(UNDER) ? path : undefined;
+}
+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 declared = index().reached;
+        const from = dirname(path);
+        for (const found of String(at.text).matchAll(SAID)) {
+            const named = nodeAt(found[1] ?? found[2] ?? found[3] ?? '', from);
+            if (named === undefined || declared.has(named))
+                continue;
+            return (`this reaches \`${named}\`, and the descent from the tree root never arrives there — so one of ` +
+                'its steps is a node nobody declared. An operation that takes a step nothing agreed to is doing ' +
+                'something this app never said it could do, and the flow reads as agreed the whole way down');
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            "import { node as ghost } from '../nodes/nd_ghost.ts'",
+            "const held = await import('../nodes/nd_ghost.ts')",
+            "const held = require('../nodes/nd_ghost.ts')",
+            "export { node as ghost } from '../nodes/nd_ghost.ts'",
+            "const AT = '../nodes/nd_ghost.ts'",
+            "import { node as invented } from 'nodes/nd_nowhere.ts'",
+        ],
+        right: [
+            "import { node as read } from '../nodes/nd_read.ts'",
+            "import { node as action } from '../nodes/nd_action.ts'\nimport { node as read } from '../nodes/nd_read.ts'",
+            "import { z } from 'zod'",
+            "import type { Operation } from '../../operations/operations.ts'",
+            "import type { Held } from '../../operations/nodes.ts'",
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_operation.js

@@ -0,0 +1,120 @@
+import { descend, read, reached } from "../../core/descend.js";
+import { rowsIn } from "./sl_unthreaded.js";
+const UNDER = 'operations/';
+const DISPATCH = 'dispatch';
+function declared() {
+    const found = new Set();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        for (const one of rowsIn(text)) {
+            const where = one.at?.split('\\').join('/');
+            if (where === undefined || !where.includes(UNDER))
+                continue;
+            if (one.id !== undefined)
+                found.add(one.id);
+            const named = where.split('/').at(-1)?.replace(/\.[^.]+$/, '');
+            if (named !== undefined)
+                found.add(named);
+        }
+    }
+    return found;
+}
+export const slopnator = {
+    on: ['CallExpression'],
+    holds: (node) => {
+        const call = node;
+        const callee = call?.callee;
+        const named = callee?.type === 'Identifier'
+            ? callee.name
+            : callee?.property?.type === 'Identifier'
+                ? callee.property.name
+                : undefined;
+        if (named !== DISPATCH)
+            return false;
+        const first = call?.arguments?.[0];
+        if (first === undefined) {
+            return ('dispatch is called with nothing to dispatch, so no operation is named and none can be found — the name ' +
+                'is the whole of what makes an operation reachable');
+        }
+        /*
+         * THE OPERATION ITSELF IS A BETTER ANSWER THAN ITS NAME, AND THIS USED TO REFUSE IT.
+         *
+         * This asked for a string literal and refused everything else, which was right when the only
+         * caller was a UI seam handed a bare name. It has been wrong since dispatch stopped taking one:
+         * the note above says so in as many words — "`dispatch` in packages/core/operations/src/dispatch.ts
+         * takes an Operation object rather than a name". What ships now imports the compiled operation
+         * and hands over the binding, and a binding cannot be assembled at run time: if it named nothing,
+         * the file would not compile.
+         *
+         * Measured 2026-08-31 on a registry install: an operations-only app, everything made by the CLI,
+         * failed its own sweep on `operations/_client.ts` — a file its own generator had just written,
+         * naming an operation the same tree declares. The gate refuses the build now, so a law that
+         * refuses a generated file is an app that cannot ship.
+         *
+         * Narrow on purpose. An identifier is accepted only when it IS one of the declared operations,
+         * which is the shape the generators emit — `import { operation as wf_charge }` and then
+         * `dispatch(wf_charge, …)`. A variable holding a computed name is still refused, because it does
+         * not match a declaration, and that is the hole this law was written for.
+         */
+        const all = declared();
+        if (first.type === 'Identifier' && typeof first.name === 'string') {
+            if (all.has(first.name))
+                return false;
+            return (`dispatch is handed \`${first.name}\`, and nothing declares an operation by that name. A binding is only ` +
+                'checkable when it is the operation — import the compiled operation and hand that over, so what runs and ' +
+                'what was declared are the same thing rather than two things that agree today');
+        }
+        if (first.type !== 'Literal' || typeof first.value !== 'string') {
+            return ('dispatch is handed a name this file does not write down, so nothing can hold it against what is declared. ' +
+                'A name assembled at runtime reads from every check exactly like a name that was checked and found — the ' +
+                'operation is reachable and no declaration was ever consulted');
+        }
+        if (all.has(first.value))
+            return false;
+        return (`dispatch names \`${String(first.value)}\` and nothing declares an operation by that name, so this reaches for ` +
+            'something that does not exist and fails where a person is waiting rather than where it was written. ' +
+            (all.size === 0
+                ? 'Nothing declares an operation at all, so no name would have been accepted — the declaration is what has to change'
+                : `Declared: ${[...all].sort().join(', ')}`));
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_operations.ts',
+                        source: "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_unknown.tsx', source: "export const HELD = dispatch('wf_not_declared')\n" },
+                ],
+                at: 'app/_probe_unknown.tsx',
+            },
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_operations.ts',
+                        source: "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_built.tsx', source: "export const HELD = dispatch(`wf_${name}`)\n" },
+                ],
+                at: 'app/_probe_built.tsx',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_operations.ts',
+                        source: "export const OPERATIONS: Threaded = {\n  id: 'operations',\n  declares: [\n    {\n      id: 'wf_send_invoice',\n      at: 'operations/wf_send_invoice.ts',\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_known.tsx', source: "export const HELD = dispatch('wf_send_invoice')\n" },
+                ],
+                at: 'app/_probe_known.tsx',
+            },
+            "export const HELD = translate('order.place')",
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undeclared_variant.js

@@ -0,0 +1,117 @@
+import { descend, read, reached } from "../../core/descend.js";
+import { rowsIn } from "./sl_unthreaded.js";
+const ELEMENT = 'element';
+const VARIANT = 'variant';
+function nameOf(id) {
+    return id
+        .split('-')
+        .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+        .join('');
+}
+function idOf(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+}
+function memberOf(id) {
+    const [first = '', ...rest] = id.split('-');
+    return first + rest.map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
+}
+function declared() {
+    const elements = new Set();
+    const variants = new Map();
+    descend();
+    for (const at of reached()) {
+        const text = read(at);
+        if (text === undefined)
+            continue;
+        let waiting = [];
+        for (const one of rowsIn(text)) {
+            if (one.id === undefined)
+                continue;
+            if (one.list === 'declares') {
+                waiting.push(one.wears === undefined ? { id: one.id } : { id: one.id, wears: one.wears });
+                continue;
+            }
+            if (one.list !== undefined)
+                continue;
+            if (one.id === ELEMENT)
+                for (const row of waiting)
+                    elements.add(nameOf(row.id));
+            if (one.id === VARIANT)
+                for (const row of waiting)
+                    variants.set(row.id, row.wears ?? []);
+            waiting = [];
+        }
+    }
+    return { elements, variants };
+}
+export const slopnator = {
+    on: ['JSXOpeningElement'],
+    holds: (node) => {
+        const name = node?.name;
+        if (name?.type !== 'JSXMemberExpression')
+            return false;
+        const element = name.object?.type === 'JSXIdentifier' ? name.object.name : undefined;
+        const member = name.property?.type === 'JSXIdentifier' ? name.property.name : undefined;
+        if (element === undefined || member === undefined)
+            return false;
+        const { elements, variants } = declared();
+        if (!elements.has(element))
+            return false;
+        const id = idOf(member);
+        const wears = variants.get(id);
+        const worn = [...variants]
+            .filter(([, all]) => all.includes(element))
+            .map(([one]) => `${element}.${memberOf(one)}`)
+            .sort();
+        const offered = worn.length === 0
+            ? `nothing declares itself worn by \`${element}\`, so no member of it would have been accepted — a variant row has to name \`${element}\` first`
+            : `\`${element}\` wears ${worn.join(', ')}`;
+        if (wears === undefined) {
+            return (`\`${element}.${member}\` names the variant \`${id}\` and nothing declares it — so it renders carrying a class ` +
+                'the stylesheet never writes, which reads on screen as an element that lost its styling and is reported ' +
+                `nowhere. ${offered}`);
+        }
+        if (!wears.includes(element)) {
+            return (`\`${element}.${member}\` pairs \`${element}\` with the variant \`${id}\`, and that variant's row does not name ` +
+                `\`${element}\` among the elements that wear it — so the pairing is nobody's declaration. ${offered}`);
+        }
+        return false;
+    },
+    proves: {
+        wrong: [
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_worn.ts',
+                        source: "export const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'button-primary',\n      at: 'app/_probe_variant.ts',\n      wears: ['Button'],\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_undeclared.tsx', source: 'export const HELD = <Button.primary />\n' },
+                ],
+                at: 'app/_probe_undeclared.tsx',
+            },
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_worn.ts',
+                        source: "export const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n    {\n      id: 'badge',\n      at: 'app/_probe_badge.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'chip',\n      at: 'app/_probe_chip.ts',\n      wears: ['Badge'],\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_mispaired.tsx', source: 'export const HELD = <Button.chip />\n' },
+                ],
+                at: 'app/_probe_mispaired.tsx',
+            },
+        ],
+        right: [
+            {
+                files: [
+                    {
+                        at: 'threads/_probe_worn.ts',
+                        source: "export const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'button-primary',\n      at: 'app/_probe_variant.ts',\n      wears: ['Button'],\n    },\n  ],\n}\n",
+                    },
+                    { at: 'app/_probe_declared.tsx', source: 'export const HELD = <Button.buttonPrimary />\n' },
+                ],
+                at: 'app/_probe_declared.tsx',
+            },
+            '<Unknown.anything />',
+        ],
+    },
+};

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

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

package/dist/integrity/slopnators/sl_undescribed.js

@@ -0,0 +1,54 @@
+const COMMON = new Set([
+    'a', 'an', 'the', 'of', 'for', 'to', 'and', 'or', 'is', 'it', 'its', 'this', 'that',
+    'in', 'on', 'at', 'as', 'by', 'with', 'be', 'are', 'was', 'one', 'every', 'each',
+]);
+const keyOf = (property) => {
+    if (property.computed === true)
+        return undefined;
+    const key = property.key;
+    if (key?.type === 'Identifier')
+        return key.name;
+    if (key?.type === 'Literal' && typeof key.value === 'string')
+        return key.value;
+    return undefined;
+};
+const said = (property) => {
+    const held = property?.value;
+    return held?.type === 'Literal' && typeof held.value === 'string' ? held.value : undefined;
+};
+const words = (text) => text.toLowerCase().split(/[^a-z]+/).filter((one) => one !== '' && !COMMON.has(one));
+export const slopnator = {
+    on: ['Property'],
+    holds: (node, at) => {
+        const property = node;
+        const key = keyOf(property);
+        if (key !== 'describes' && key !== 'means')
+            return false;
+        const sentence = said(property);
+        if (sentence === undefined)
+            return false;
+        if (sentence.trim() === '')
+            return `\`${key}\` is empty, so the word arrived and the meaning never did`;
+        const owner = at.ancestors().at(-1);
+        const id = said((owner?.properties ?? []).find((one) => keyOf(one) === 'id' || keyOf(one) === 'name'));
+        if (id === undefined)
+            return false;
+        const own = new Set(words(id));
+        if (words(sentence).some((word) => !own.has(word)))
+            return false;
+        return `\`${key}\` says "${sentence}", which adds no word its id \`${id}\` does not already carry`;
+    },
+    proves: {
+        wrong: [
+            "const M = { id: 'law', describes: 'The law.' }",
+            "const M = { id: 'law', describes: '' }",
+            "const M = { id: 'term', means: '' }",
+            "const M = { id: 'thread-check', describes: 'The thread check.' }",
+        ],
+        right: [
+            "const M = { id: 'law', describes: 'A rule that must be guaranteed to be enforced.' }",
+            "const M = { id: 'term', means: 'A word this repository coins, and what somebody reading it should understand.' }",
+            "const M = { id: 'law', at: 'packages/core/integrity/src/constraint.ts' }",
+        ],
+    },
+};

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

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