slopless 0.2.23 → 0.2.24

package/dist/rules/semantic-thinness/patterns/empty-quantification.json

@@ -0,0 +1,33 @@
+{
+    "id": "empty-quantification",
+    "class": "empty-quantification",
+    "purpose": "Catch claims that minimize an unexplained act of quantification instead of naming the metric, measurement, or result.",
+    "matchMode": "suffix",
+    "maxTokens": 24,
+    "templates": ["{minimizer} put a number on {deicticObject}."],
+    "slots": {
+        "minimizer": ["just", "simply", "merely", "basically"],
+        "deicticObject": ["it", "this", "that"]
+    },
+    "rejectIf": [
+        "sentence names the metric, measured value, scale, or numbered label",
+        "sentence explains how the number was calculated or where it came from",
+        "sentence uses put literally rather than as an empty quantification claim"
+    ],
+    "positiveExamples": [
+        "The report just put a number on it.",
+        "The dashboard simply put a number on this.",
+        "The analysis merely put a number on that.",
+        "The model basically put a number on it."
+    ],
+    "negativeExamples": [
+        "The analyst labeled the third bar 42.",
+        "The meter measured the pressure at 18 PSI.",
+        "The report calculated the score from twelve survey responses.",
+        "She put the numbered label on the archive box."
+    ],
+    "notes": [
+        "The template begins at the minimizer so suffix mode permits arbitrary preceding subjects without enumerating them.",
+        "Suffix mode permits arbitrary preceding subjects but requires the vague quantification phrase to end the sentence, excluding measurements, explanations, and literal continuations."
+    ]
+}

package/dist/rules/semantic-thinness/private/pattern-data-e.js

@@ -1,5 +1,7 @@
+import emptyQuantification from "../patterns/empty-quantification.json" with { type: "json" };
 import recursiveMeaningFrame from "../patterns/recursive-meaning-frame.json" with { type: "json" };
 export const semanticThinnessPatternSetE = [
+    emptyQuantification,
     recursiveMeaningFrame
 ];
 //# sourceMappingURL=pattern-data-e.js.map

package/dist/rules/semantic-thinness/private/pattern-matcher.js

@@ -86,7 +86,12 @@ function compileSlotValues(slots) {
     return compiled;
 }
 export function compileSemanticThinnessPatterns(patterns) {
-    const matchModeFor = (pattern) => pattern.matchMode === "contains" ? "contains" : "full";
+    const matchModeFor = (pattern) => {
+        if (pattern.matchMode === "contains" || pattern.matchMode === "suffix") {
+            return pattern.matchMode;
+        }
+        return "full";
+    };
     const defaultMaxTokensFor = (pattern) => matchModeFor(pattern) === "contains"
         ? CONTAINS_MAX_TOKENS
         : FULL_MAX_TOKENS;

package/dist/rules/syntactic-patterns/closers/affirmation-closers.js

@@ -2,6 +2,10 @@ import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
 import { sectionLastSentenceUnits, sentenceUnits } from "../../../adapters/textlint/units.js";
 import { wordTokens } from "../../../shared/text/tokens.js";
 const CLOSERS = ["and that's the key.", "that's what matters."];
+const EXACT_FORMULA_LINES = new Set([
+    "that's the good stuff",
+    "that is the good stuff"
+]);
 const FORMULA_TAILS = [
     "key",
     "point",
@@ -13,9 +17,15 @@ const FORMULA_TAILS = [
 ];
 function isFormulaLine(text) {
     const lower = text.toLocaleLowerCase("en");
-    return (wordTokens(text).length <= 6 &&
-        (lower.startsWith("that's the ") || lower.startsWith("that is the ")) &&
-        FORMULA_TAILS.some((tail) => lower.includes(tail)));
+    let punctuationStart = lower.length;
+    while ([".", "!", "?"].includes(lower[punctuationStart - 1] ?? "")) {
+        punctuationStart -= 1;
+    }
+    const withoutTerminalPunctuation = lower.slice(0, punctuationStart);
+    return (EXACT_FORMULA_LINES.has(withoutTerminalPunctuation) ||
+        (wordTokens(text).length <= 6 &&
+            (lower.startsWith("that's the ") || lower.startsWith("that is the ")) &&
+            FORMULA_TAILS.some((tail) => lower.includes(tail))));
 }
 const rule = defineTextlintRule({
     detector: {

package/dist/rules/syntactic-patterns/contrast/private/copular-reframe.js

@@ -0,0 +1,41 @@
+import { NEGATION_WORDS, findCopularNegation, pronounCopulaStart, skipOptionalAdverbs, startsWithPronounCopula, startsWithWords, startsWithSubjectCopula, validSubject, words } from "./negation-reframe-parts.js";
+export function sameSubjectCopularReframe(aTokens, bTokens) {
+    const negation = findCopularNegation(aTokens);
+    if (negation === undefined || !validSubject(negation.subject)) {
+        return false;
+    }
+    return startsWithSubjectCopula(bTokens, negation.subject, negation.affirmativeAux);
+}
+export function pronounCopularReframe(aTokens, bTokens) {
+    const negation = findCopularNegation(aTokens);
+    return (negation !== undefined &&
+        validSubject(negation.subject) &&
+        !startsWithNegatedPronounCopula(bTokens) &&
+        startsWithPronounCopula(bTokens));
+}
+export function progressiveVerbMirror(aTokens, bTokens) {
+    const negation = findCopularNegation(aTokens);
+    if (negation === undefined || !validSubject(negation.subject)) {
+        return false;
+    }
+    const tokenWords = words(aTokens);
+    const predicateIndex = skipOptionalAdverbs(tokenWords, negation.negatedPredicateStart);
+    const verb = tokenWords[predicateIndex];
+    return (verb !== undefined &&
+        verb.endsWith("ing") &&
+        startsWithWords(bTokens, [
+            ...negation.subject,
+            negation.affirmativeAux,
+            verb
+        ]));
+}
+export function startsWithNegatedPronounCopula(tokens) {
+    const start = pronounCopulaStart(tokens);
+    if (start === undefined) {
+        return false;
+    }
+    const tokenWords = words(tokens);
+    const predicateIndex = skipOptionalAdverbs(tokenWords, start.predicateStart);
+    return NEGATION_WORDS.has(tokenWords[predicateIndex] ?? "");
+}
+//# sourceMappingURL=copular-reframe.js.map

package/dist/rules/syntactic-patterns/contrast/private/negation-reframe-matcher.js

@@ -1,9 +1,9 @@
-import { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, NEGATION_WORDS, PASSIVE_DEFINITION_VERBS, PRONOUN_REFRAME_STARTS, contrastPivotSubject, findCopularNegation, findNegationIndex, isCompleteSentence, skipOptionalAdverbs, startsWithAny, startsWithSubjectOrPronoun, startsWithSubjectVerb, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
+import { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, contrastPivotSubject, findCopularNegation, findNegationIndex, isCompleteSentence, skipOptionalAdverbs, startsWithSubjectOrPronoun, startsWithSubjectVerb, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
 import { hasAbstractCommaContrast, hasAbstractNegationPayoff, hasFactualConnectorAfterNegation, hasMetaContext } from "./negation-context-gates.js";
 import { hasInlineContrastConnectorAfterNegation } from "./inline-contrast-connector.js";
 import { inlineNotBecauseReframe } from "./inline-not-because-reframe.js";
 import { inlineNotJustCopularReframe, inlineShortNegatedBeat } from "./inline-short-negation.js";
-import { hasNegativeSlopPairSignal, negativeSlopReframe } from "./negative-slop-frames.js";
+import { hasNegativeSlopPairSignal, negatedActionPronounPayoff, negatedActionSetReplacement, negativeSlopReframe, progressiveVerbMirror, pronounCopularReframe, sameSubjectCopularReframe, shouldReportCopularReframe, startsWithNegatedPronounCopula } from "./negative-slop-frames.js";
 import { makeMeaningReframe, meaningReframe } from "./meaning-reframe.js";
 import { hasConcreteCorrectionEvidence } from "../../../../shared/matchers/concrete-evidence.js";
 import { splitSentences } from "../../../../shared/text/sentences.js";
@@ -60,51 +60,6 @@ function inlineNegationContrast(sentence) {
         }
         : undefined;
 }
-function sameSubjectCopularReframe(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    if (negation === undefined || !validSubject(negation.subject)) {
-        return false;
-    }
-    return startsWithWords(bTokens, [
-        ...negation.subject,
-        negation.affirmativeAux
-    ]);
-}
-function pronounCopularReframe(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    return (negation !== undefined &&
-        validSubject(negation.subject) &&
-        !looksLikePassiveDefinition(aTokens, bTokens) &&
-        !startsWithNegatedPronounCopula(bTokens) &&
-        startsWithAny(bTokens, PRONOUN_REFRAME_STARTS));
-}
-function startsWithNegatedPronounCopula(tokens) {
-    for (const start of PRONOUN_REFRAME_STARTS) {
-        if (!startsWithWords(tokens, start)) {
-            continue;
-        }
-        const tokenWords = words(tokens);
-        const predicateIndex = skipOptionalAdverbs(tokenWords, start.length);
-        return NEGATION_WORDS.has(tokenWords[predicateIndex] ?? "");
-    }
-    return false;
-}
-function progressiveVerbMirror(aTokens, bTokens) {
-    const negation = findCopularNegation(aTokens);
-    if (negation === undefined || !validSubject(negation.subject)) {
-        return false;
-    }
-    const tokenWords = words(aTokens);
-    const predicateIndex = skipOptionalAdverbs(tokenWords, negation.negatedPredicateStart);
-    const verb = tokenWords[predicateIndex];
-    return (verb !== undefined &&
-        verb.endsWith("ing") &&
-        startsWithWords(bTokens, [
-            ...negation.subject,
-            negation.affirmativeAux,
-            verb
-        ]));
-}
 function needReframe(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     for (let index = 0; index < tokenWords.length; index += 1) {
@@ -172,43 +127,36 @@ function startsWithExplicitReplacement(tokens) {
 }
 function hasPairNegationSignal(tokens) {
     return (findNegationIndex(tokens) !== undefined ||
+        findCopularNegation(tokens) !== undefined ||
         contrastPivotSubject(tokens) !== undefined ||
         hasNegativeSlopPairSignal(tokens));
 }
-function looksLikePassiveDefinition(aTokens, bTokens) {
-    const aWords = words(aTokens);
-    const bWords = words(bTokens);
-    for (let index = 0; index < aWords.length - 2; index += 1) {
-        const current = aWords[index];
-        if ((current === "has" || current === "have" || current === "had") &&
-            aWords[index + 1] === "not" &&
-            aWords[index + 2] === "been" &&
-            startsWithWords(bTokens, ["it", "is"]) &&
-            PASSIVE_DEFINITION_VERBS.has(bWords[2] ?? "")) {
-            return true;
-        }
-    }
-    return false;
-}
 function sentencePairReframe(a, b) {
     const aTokens = wordTokens(a.text);
     const bTokens = wordTokens(b.text);
+    const pairText = `${a.text} ${b.text}`;
+    const hasNegatedActionSetReplacement = negatedActionSetReplacement(aTokens, bTokens);
+    const hasAllowedReplacementColon = b.text.trimEnd().endsWith(":") && hasNegatedActionSetReplacement;
     if (!isCompleteSentence(a) ||
-        !isCompleteSentence(b) ||
+        (!isCompleteSentence(b) && !hasAllowedReplacementColon) ||
         !hasPairNegationSignal(aTokens)) {
         return undefined;
     }
-    if (sameSubjectCopularReframe(aTokens, bTokens) ||
-        pronounCopularReframe(aTokens, bTokens) ||
-        progressiveVerbMirror(aTokens, bTokens) ||
+    if ((shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+        (sameSubjectCopularReframe(aTokens, bTokens) ||
+            pronounCopularReframe(aTokens, bTokens) ||
+            progressiveVerbMirror(aTokens, bTokens))) ||
         (startsWithExplicitReplacement(bTokens) &&
-            !hasConcreteCorrectionEvidence(`${a.text} ${b.text}`)) ||
+            shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+            !hasConcreteCorrectionEvidence(pairText)) ||
         meaningReframe(aTokens, bTokens) ||
         makeMeaningReframe(aTokens, bTokens) ||
         needReframe(aTokens, bTokens) ||
         actionVerbMirror(aTokens, bTokens) ||
+        negatedActionPronounPayoff(aTokens, bTokens) ||
         negativeSlopReframe(aTokens, bTokens) ||
-        explicitContrastPivotReframe(aTokens, bTokens)) {
+        (shouldReportCopularReframe(aTokens, bTokens, pairText) &&
+            explicitContrastPivotReframe(aTokens, bTokens))) {
         return {
             end: b.end,
             start: a.start,

package/dist/rules/syntactic-patterns/contrast/private/negation-reframe-parts.js

@@ -1,5 +1,6 @@
 export const NEGATION_WORDS = new Set([
     "not",
+    "never",
     "isn't",
     "aren't",
     "wasn't",
@@ -52,18 +53,22 @@ export const PRONOUN_REFRAME_STARTS = [
     ["you", "are"],
     ["we", "are"]
 ];
-export const PASSIVE_DEFINITION_VERBS = new Set([
-    "associated",
-    "caused",
-    "classified",
-    "defined",
-    "described",
-    "linked",
-    "marked",
-    "produced"
-]);
 const IRREGULAR_PAST_TENSE = new Map([["go", "went"]]);
 const CONTRAST_PIVOT_AFTER_NOT = new Set(["just", "merely", "only"]);
+const NEGATIVE_COPULAR_PREDICATES = new Set([
+    "never",
+    "nobody",
+    "none",
+    "nothing",
+    "nowhere"
+]);
+const CONTRACTED_PRONOUN_COPULAS = new Map([
+    ["it's", { affirmativeAux: "is", subject: ["it"] }],
+    ["that's", { affirmativeAux: "is", subject: ["that"] }],
+    ["they're", { affirmativeAux: "are", subject: ["they"] }],
+    ["we're", { affirmativeAux: "are", subject: ["we"] }],
+    ["you're", { affirmativeAux: "are", subject: ["you"] }]
+]);
 export function findNegationIndex(tokens) {
     for (let index = 0; index < tokens.length; index += 1) {
         const token = tokens[index];
@@ -121,6 +126,39 @@ export function skipOptionalAdverbs(tokens, start) {
 export function startsWithAny(tokens, starts) {
     return starts.some((start) => startsWithWords(tokens, start));
 }
+export function pronounCopulaStart(tokens) {
+    const firstToken = tokens[0];
+    const contracted = firstToken === undefined
+        ? undefined
+        : CONTRACTED_PRONOUN_COPULAS.get(firstToken.normalized);
+    if (contracted !== undefined) {
+        return { ...contracted, predicateStart: 1 };
+    }
+    for (const start of PRONOUN_REFRAME_STARTS) {
+        if (startsWithWords(tokens, start)) {
+            return {
+                affirmativeAux: start[1],
+                predicateStart: start.length,
+                subject: [start[0]]
+            };
+        }
+    }
+    return undefined;
+}
+export function startsWithPronounCopula(tokens) {
+    return pronounCopulaStart(tokens) !== undefined;
+}
+export function startsWithSubjectCopula(tokens, subject, affirmativeAux) {
+    if (startsWithWords(tokens, [...subject, affirmativeAux])) {
+        return true;
+    }
+    const contracted = CONTRACTED_PRONOUN_COPULAS.get(tokens[0]?.normalized ?? "");
+    if (contracted?.affirmativeAux !== affirmativeAux) {
+        return false;
+    }
+    return (subject.length === contracted.subject.length &&
+        subject.every((word, index) => word === contracted.subject[index]));
+}
 export function isCompleteSentence(sentence) {
     const trimmed = sentence.text.trim();
     const last = trimmed.at(-1);
@@ -161,6 +199,24 @@ export function findCopularNegation(tokens) {
                 subject: tokenWords.slice(0, index)
             };
         }
+        if (explicitAux !== undefined &&
+            next !== undefined &&
+            NEGATIVE_COPULAR_PREDICATES.has(next)) {
+            return {
+                affirmativeAux: explicitAux,
+                negatedPredicateStart: index + 1,
+                subject: tokenWords.slice(0, index)
+            };
+        }
+        if (explicitAux !== undefined &&
+            next === "no" &&
+            (tokenWords[index + 2] === "one" || tokenWords[index + 2] === "single")) {
+            return {
+                affirmativeAux: explicitAux,
+                negatedPredicateStart: index + 1,
+                subject: tokenWords.slice(0, index)
+            };
+        }
     }
     return undefined;
 }

package/dist/rules/syntactic-patterns/contrast/private/negative-slop-frames.js

@@ -1,3 +1,7 @@
+import { hasFactualConnectorAfterNegation } from "./negation-context-gates.js";
+import { hasAbstractPolicyDirectObject } from "./policy-object.js";
+export { shouldReportCopularReframe } from "./reframe-classification.js";
+export { progressiveVerbMirror, pronounCopularReframe, sameSubjectCopularReframe, startsWithNegatedPronounCopula } from "./copular-reframe.js";
 import { DO_NEGATIONS, EXPLICIT_DO_AUXILIARIES, FACTUAL_NEGATION_CONNECTORS, PRONOUN_REFRAME_STARTS, hasAnyWord, skipOptionalAdverbs, startsWithAny, startsWithSubjectOrPronoun, startsWithWords, stripLeadingPairPivot, validSubject, words } from "./negation-reframe-parts.js";
 const GENERIC_ACTION_VERBS = new Set([
     "asked",
@@ -27,6 +31,40 @@ const GENERIC_ACTION_VERBS = new Set([
     "walked",
     "went"
 ]);
+const NEGATED_ACTION_REFRAME_VERBS = new Set([
+    "avoid",
+    "change",
+    "create",
+    "end",
+    "erase",
+    "fix",
+    "guarantee",
+    "make",
+    "mean",
+    "remove",
+    "replace",
+    "require",
+    "skip",
+    "solve"
+]);
+const REPLACEMENT_SUBJECT_PRONOUNS = new Set(["he", "she"]);
+const PRONOUN_PAYOFF_VERBS = new Set([
+    "becomes",
+    "creates",
+    "depends",
+    "exposes",
+    "lands",
+    "means",
+    "moves",
+    "needs",
+    "points",
+    "requires",
+    "reveals",
+    "shifts",
+    "shows",
+    "turns"
+]);
+const PRONOUN_SUBJECTS = new Set(["it", "this", "that", "they", "we", "you"]);
 function startsWithPassiveCopula(tokens) {
     const tokenWords = words(tokens);
     const predicateIndex = startsWithAny(tokens, PRONOUN_REFRAME_STARTS)
@@ -81,7 +119,34 @@ function negatedActionSubject(tokens) {
     }
     return undefined;
 }
-function negativeActionReplacement(aTokens, bTokens) {
+function constrainedSetSubjectLength(tokens, subject) {
+    if (startsWithWords(tokens, subject)) {
+        return subject.length;
+    }
+    if (startsWithSubjectOrPronoun(tokens, subject)) {
+        return 1;
+    }
+    return subject.length > 1 &&
+        REPLACEMENT_SUBJECT_PRONOUNS.has(tokens[0]?.normalized ?? "")
+        ? 1
+        : undefined;
+}
+export function negatedActionReplacement(aTokens, bTokens) {
+    const tokenWords = words(aTokens);
+    const subject = negatedActionSubject(aTokens);
+    if (subject === undefined) {
+        return false;
+    }
+    const bContentTokens = stripLeadingPairPivot(bTokens);
+    const bWords = words(bContentTokens);
+    const genericVerbIndex = skipOptionalAdverbs(bWords, subject.length);
+    return (tokenWords.length <= 14 &&
+        !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
+        ((startsWithSubjectOrPronoun(bContentTokens, subject) &&
+            GENERIC_ACTION_VERBS.has(bWords[genericVerbIndex] ?? "")) ||
+            negatedActionSetReplacement(aTokens, bTokens)));
+}
+export function negatedActionSetReplacement(aTokens, bTokens) {
     const tokenWords = words(aTokens);
     const subject = negatedActionSubject(aTokens);
     if (subject === undefined) {
@@ -89,13 +154,14 @@ function negativeActionReplacement(aTokens, bTokens) {
     }
     const bContentTokens = stripLeadingPairPivot(bTokens);
     const bWords = words(bContentTokens);
-    const verbIndex = skipOptionalAdverbs(bWords, subject.length);
-    const verb = bWords[verbIndex];
+    const subjectLength = constrainedSetSubjectLength(bContentTokens, subject);
+    const verbIndex = subjectLength === undefined
+        ? undefined
+        : skipOptionalAdverbs(bWords, subjectLength);
     return (tokenWords.length <= 14 &&
         !hasAnyWord(tokenWords, FACTUAL_NEGATION_CONNECTORS) &&
-        startsWithSubjectOrPronoun(bContentTokens, subject) &&
-        verb !== undefined &&
-        GENERIC_ACTION_VERBS.has(verb));
+        verbIndex !== undefined &&
+        hasAbstractPolicyDirectObject(bWords, verbIndex));
 }
 function notBecauseReframe(aTokens, bTokens) {
     return (startsWithWords(aTokens, ["not", "because"]) &&
@@ -130,10 +196,47 @@ export function hasNegativeSlopPairSignal(tokens) {
         hasTrailingProblemFrame(tokenWords) ||
         hasLeadingProblemFrame(tokenWords));
 }
+export function negatedActionPronounPayoff(aTokens, bTokens) {
+    const aWords = words(aTokens);
+    const bWords = words(stripLeadingPairPivot(bTokens));
+    const pronounStart = PRONOUN_SUBJECTS.has(bWords[0] ?? "") ? 1 : undefined;
+    if (pronounStart === undefined) {
+        return false;
+    }
+    const payoffVerbIndex = skipOptionalAdverbs(bWords, pronounStart);
+    if (!PRONOUN_PAYOFF_VERBS.has(bWords[payoffVerbIndex] ?? "")) {
+        return false;
+    }
+    for (let index = 0; index < aWords.length; index += 1) {
+        if (hasNegatedReframeVerb(aTokens, aWords, index)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasNegatedReframeVerb(tokens, tokenWords, index) {
+    const current = tokenWords[index];
+    const next = tokenWords[index + 1];
+    const subject = tokenWords.slice(0, index);
+    if (!validSubject(subject)) {
+        return false;
+    }
+    const negationIndex = DO_NEGATIONS.has(current ?? "")
+        ? index
+        : EXPLICIT_DO_AUXILIARIES.has(current ?? "") && next === "not"
+            ? index + 1
+            : undefined;
+    if (negationIndex === undefined ||
+        hasFactualConnectorAfterNegation(tokens, negationIndex)) {
+        return false;
+    }
+    const verbIndex = skipOptionalAdverbs(tokenWords, negationIndex + 1);
+    return NEGATED_ACTION_REFRAME_VERBS.has(tokenWords[verbIndex] ?? "");
+}
 export function negativeSlopReframe(aTokens, bTokens) {
     return (noLongerCopularReframe(aTokens, bTokens) ||
         fragmentDefinitionReframe(aTokens, bTokens) ||
-        negativeActionReplacement(aTokens, bTokens) ||
+        negatedActionReplacement(aTokens, bTokens) ||
         notBecauseReframe(aTokens, bTokens) ||
         notProblemReframe(aTokens, bTokens));
 }

package/dist/rules/syntactic-patterns/contrast/private/policy-object.js

@@ -0,0 +1,55 @@
+const ABSTRACT_POLICY_OBJECTS = new Set([
+    "condition",
+    "criterion",
+    "policy",
+    "principle",
+    "requirement",
+    "rule",
+    "standard",
+    "threshold"
+]);
+const DIRECT_OBJECT_DETERMINERS = new Set([
+    "a",
+    "an",
+    "one",
+    "that",
+    "the",
+    "this"
+]);
+const POLICY_OBJECT_MODIFIERS = new Set([
+    "access",
+    "approval",
+    "business",
+    "content",
+    "deployment",
+    "editorial",
+    "governance",
+    "launch",
+    "operating",
+    "pricing",
+    "quality",
+    "release",
+    "review",
+    "safety",
+    "security",
+    "service",
+    "spending",
+    "technical",
+    "testing",
+    "usage"
+]);
+export function hasAbstractPolicyDirectObject(tokenWords, verbIndex) {
+    if (!["set", "sets"].includes(tokenWords[verbIndex] ?? "")) {
+        return false;
+    }
+    const objectTokens = tokenWords.slice(verbIndex + 1);
+    const directObject = DIRECT_OBJECT_DETERMINERS.has(objectTokens[0] ?? "")
+        ? objectTokens.slice(1)
+        : objectTokens;
+    const [first, second] = directObject;
+    return ((directObject.length === 1 && ABSTRACT_POLICY_OBJECTS.has(first ?? "")) ||
+        (directObject.length === 2 &&
+            POLICY_OBJECT_MODIFIERS.has(first ?? "") &&
+            ABSTRACT_POLICY_OBJECTS.has(second ?? "")));
+}
+//# sourceMappingURL=policy-object.js.map

package/dist/rules/syntactic-patterns/contrast/private/reframe-classification.js

@@ -0,0 +1,193 @@
+import { FACTUAL_NEGATION_CONNECTORS, findCopularNegation, pronounCopulaStart, stripLeadingPairPivot, words } from "./negation-reframe-parts.js";
+const FRAMING_SUBJECT_NOUNS = new Set([
+    "answer",
+    "fix",
+    "goal",
+    "issue",
+    "key",
+    "point",
+    "problem",
+    "solution",
+    "strategy"
+]);
+const INSTRUCTION_ADJECTIVES = new Set([
+    "best",
+    "better",
+    "critical",
+    "essential",
+    "important",
+    "necessary",
+    "recommended",
+    "safest"
+]);
+const CONCRETE_PASSIVE_VERBS = new Set([
+    "associated",
+    "caused",
+    "classified",
+    "created",
+    "entered",
+    "linked",
+    "owned",
+    "paid",
+    "passed",
+    "produced",
+    "recorded",
+    "regulated",
+    "sent",
+    "stored",
+    "used"
+]);
+const REFERENCE_PASSIVE_VERBS = new Set(["defined", "described", "marked"]);
+const PASSIVE_EXPLANATION_LINKS = new Set([
+    "as",
+    "by",
+    "for",
+    "from",
+    "in",
+    "to",
+    "with"
+]);
+const CLAUSE_BOUNDARIES = new Set([
+    "and",
+    "but",
+    "that",
+    "when",
+    "where",
+    "which",
+    "while"
+]);
+const CONCRETE_RELATIONS = [
+    ["amount", "of"],
+    ["defined", "to", "be"],
+    ["derived", "from"],
+    ["intended", "for"],
+    ["owned", "by"],
+    ["property", "of"],
+    ["symptom", "of"],
+    ["unit", "of"]
+];
+const MAX_SHORT_SENTENCE_WORDS = 6;
+const QUANTITY_WORDS = new Set([
+    "half",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten"
+]);
+function digitTokenCount(tokens) {
+    return tokens.filter((token) => [...token.text].some((character) => character >= "0" && character <= "9")).length;
+}
+function quantityTokenCount(tokens) {
+    return (digitTokenCount(tokens) +
+        tokens.filter((token) => QUANTITY_WORDS.has(token.normalized)).length);
+}
+function acronymCount(tokens) {
+    return tokens.filter((token) => token.text.length >= 2 &&
+        token.text === token.text.toLocaleUpperCase("en") &&
+        token.text !== token.text.toLocaleLowerCase("en")).length;
+}
+function properNameCount(tokens) {
+    return tokens.filter((token, index) => {
+        const first = token.text[0];
+        return (index > 0 &&
+            first !== undefined &&
+            first >= "A" &&
+            first <= "Z" &&
+            token.text !== token.text.toLocaleUpperCase("en"));
+    }).length;
+}
+function hasReferenceEvidence(aTokens, bTokens, pairText) {
+    const digits = digitTokenCount(aTokens) + digitTokenCount(bTokens);
+    const quantities = quantityTokenCount(aTokens) + quantityTokenCount(bTokens);
+    const names = properNameCount(aTokens) + properNameCount(bTokens);
+    return (digits >= 2 ||
+        pairText.includes("/") ||
+        pairText.includes("_") ||
+        pairText.includes("@") ||
+        (acronymCount(aTokens) + acronymCount(bTokens) >= 1 && digits >= 1) ||
+        names >= 3 ||
+        (names >= 2 && quantities >= 1));
+}
+function startsWithSequence(source, sequence) {
+    return sequence.every((word, index) => source[index] === word);
+}
+function containsSequence(source, sequence) {
+    for (let index = 0; index <= source.length - sequence.length; index += 1) {
+        if (startsWithSequence(source.slice(index), sequence)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasConcreteRelation(tokenWords) {
+    return CONCRETE_RELATIONS.some((relation) => containsSequence(tokenWords, relation));
+}
+function hasInstruction(tokens) {
+    const tokenWords = words(tokens);
+    const start = pronounCopulaStart(tokens);
+    return (start !== undefined &&
+        INSTRUCTION_ADJECTIVES.has(tokenWords[start.predicateStart] ?? "") &&
+        tokenWords[start.predicateStart + 1] === "to");
+}
+function hasPassiveExplanation(bTokens) {
+    const tokenWords = words(bTokens);
+    const start = pronounCopulaStart(bTokens);
+    const isConcretePassive = (word) => CONCRETE_PASSIVE_VERBS.has(word) || REFERENCE_PASSIVE_VERBS.has(word);
+    if (start !== undefined &&
+        isConcretePassive(tokenWords[start.predicateStart] ?? "")) {
+        return true;
+    }
+    const boundary = tokenWords.findIndex((word) => CLAUSE_BOUNDARIES.has(word));
+    const firstClause = boundary < 0 ? tokenWords : tokenWords.slice(0, boundary);
+    return firstClause.some((word, index) => isConcretePassive(word) &&
+        PASSIVE_EXPLANATION_LINKS.has(firstClause[index + 1] ?? ""));
+}
+function hasPurposeOrProvenance(tokenWords) {
+    return (containsSequence(tokenWords, ["used", "to"]) ||
+        (["uses", "used"].includes(tokenWords[1] ?? "") &&
+            tokenWords.some((word, index) => ["created", "produced"].includes(word) &&
+                ["by", "from", "in"].includes(tokenWords[index + 1] ?? ""))));
+}
+function hasCausalPassiveExplanation(aTokens, bTokens) {
+    return (words(aTokens).some((word) => FACTUAL_NEGATION_CONNECTORS.has(word)) &&
+        hasPassiveExplanation(bTokens));
+}
+function hasDistinctCauseExplanation(aTokens, bTokens) {
+    const aWords = words(aTokens);
+    const bWords = words(stripLeadingPairPivot(bTokens));
+    return (!aWords.includes("caused") && containsSequence(bWords, ["caused", "by"]));
+}
+function hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText) {
+    const tokenWords = words(stripLeadingPairPivot(bTokens));
+    return (hasInstruction(bTokens) ||
+        hasConcreteRelation(tokenWords) ||
+        hasPurposeOrProvenance(tokenWords) ||
+        hasDistinctCauseExplanation(aTokens, bTokens) ||
+        hasCausalPassiveExplanation(aTokens, bTokens) ||
+        (hasReferenceEvidence(aTokens, bTokens, pairText) &&
+            hasPassiveExplanation(bTokens)));
+}
+function hasFramingNoun(tokens) {
+    const negation = findCopularNegation(tokens);
+    if (negation === undefined) {
+        return false;
+    }
+    const predicate = words(tokens).slice(negation.negatedPredicateStart, negation.negatedPredicateStart + 4);
+    return [...negation.subject, ...predicate].some((word) => FRAMING_SUBJECT_NOUNS.has(word));
+}
+function isShortReversal(aTokens, bTokens) {
+    return (aTokens.length <= MAX_SHORT_SENTENCE_WORDS &&
+        bTokens.length <= MAX_SHORT_SENTENCE_WORDS);
+}
+export function shouldReportCopularReframe(aTokens, bTokens, pairText) {
+    return (isShortReversal(aTokens, bTokens) ||
+        hasFramingNoun(aTokens) ||
+        !hasConcreteExplanatoryEvidence(aTokens, bTokens, pairText));
+}
+//# sourceMappingURL=reframe-classification.js.map

package/dist/rules/syntactic-patterns/lead-ins/generic-signposting.js

@@ -1,7 +1,7 @@
 import { hasConcreteImplementationSummary } from "../../../shared/matchers/concrete-evidence.js";
 import { cleanSentence, containsAny, tokens } from "../../../shared/matchers/prose-patterns.js";
 import { oneToOneRule } from "../../private/textlint-rule-builders.js";
-import { matchDiscourseEvaluationFrame } from "./private/discourse-evaluation.js";
+import { isAbstractAuditFrame, matchDiscourseEvaluationFrame, matchExpandedDiscourseFrame } from "./private/discourse-evaluation.js";
 const PREFIXES = ["however, ", "but ", "and ", "so "];
 // "as such" was removed: it is a normal anaphoric connective ("a registered adviser; as
 // such, it must...") and was the dominant false positive, not a signposting frame.
@@ -47,7 +47,6 @@ const FRAME_PATTERNS = [
     "the useful version is",
     "the point is plain enough"
 ];
-const DETERMINERS = ["a", "an", "the", "this", "that"];
 const SEQUENCE_PATTERNS = [
     "a simple sequence works well",
     "a simple pattern works well",
@@ -88,72 +87,9 @@ const WHAT_FRAME_TAIL_STARTERS = [
     "true",
     "usually"
 ];
-const FRAME_ADJECTIVES = [
-    "basic",
-    "best",
-    "better",
-    "biggest",
-    "bigger",
-    "central",
-    "clearest",
-    "core",
-    "easiest",
-    "final",
-    "first",
-    "hardest",
-    "honest",
-    "important",
-    "main",
-    "only",
-    "obvious",
-    "practical",
-    "real",
-    "simple",
-    "useful"
-];
-const FRAME_NOUNS = [
-    "answer",
-    "approach",
-    "challenge",
-    "choice",
-    "conclusion",
-    "fact",
-    "fix",
-    "focus",
-    "frame",
-    "idea",
-    "lesson",
-    "move",
-    "path",
-    "point",
-    "principle",
-    "priority",
-    "problem",
-    "question",
-    "result",
-    "rule",
-    "shift",
-    "signal",
-    "strategy",
-    "test",
-    "thing",
-    "tradeoff",
-    "truth",
-    "version",
-    "way",
-    "win"
-];
-const ABSTRACT_FRAME_VERBS = ["is", "are", "was"];
 const POINT_NOUNS = ["goal", "job", "key", "point", "takeaway", "trick"];
 function matchModifiedAbstractFrame(words) {
-    const [first, second, third, fourth, fifth] = words;
-    if (first === "the" &&
-        second === "result" &&
-        third === "worth" &&
-        fourth === "caring" &&
-        fifth === "about") {
-        return "the-result-worth-caring-about";
-    }
+    const [first, second, third, fourth] = words;
     if (first !== "the") {
         return undefined;
     }
@@ -167,20 +103,6 @@ function matchModifiedAbstractFrame(words) {
     ]);
     return matches.get(key);
 }
-function matchEvaluativeFrame(words) {
-    const [first, second, third, fourth] = words;
-    if (first !== undefined &&
-        second !== undefined &&
-        third !== undefined &&
-        fourth !== undefined &&
-        DETERMINERS.includes(first) &&
-        FRAME_ADJECTIVES.includes(second) &&
-        FRAME_NOUNS.includes(third) &&
-        ABSTRACT_FRAME_VERBS.includes(fourth)) {
-        return `the-${second}-${third}-${fourth}`;
-    }
-    return undefined;
-}
 function matchPointIsToFrame(words) {
     const [first, second, third, fourth, fifth] = words;
     if (first === "the" &&
@@ -217,8 +139,8 @@ function matchWhatFrame(words) {
 }
 function matchAbstractFrame(text) {
     const words = tokens(text);
-    return (matchModifiedAbstractFrame(words) ??
-        matchEvaluativeFrame(words) ??
+    return (matchExpandedDiscourseFrame(words) ??
+        matchModifiedAbstractFrame(words) ??
         matchDiscourseEvaluationFrame(words) ??
         matchPointIsToFrame(words) ??
         matchWhatFrame(words));
@@ -266,8 +188,14 @@ function matchGeneratedFormula(text) {
 }
 function matchSignposting(sentence) {
     const stripped = cleanSentence(sentence, PREFIXES);
-    const concreteImplementation = hasConcreteImplementationSummary(stripped);
     const abstract = matchAbstractFrame(stripped);
+    const strippedWords = tokens(stripped);
+    const auditStart = isAbstractAuditFrame(strippedWords)
+        ? stripped.indexOf("audit")
+        : -1;
+    const concreteImplementation = hasConcreteImplementationSummary(abstract !== undefined && auditStart >= 0
+        ? stripped.slice(0, auditStart) + stripped.slice(auditStart + 5)
+        : stripped);
     const formulaicSetup = matchFormulaicContentSetup(stripped);
     const generatedFormula = matchGeneratedFormula(stripped);
     if (abstract !== undefined && !concreteImplementation) {
@@ -279,6 +207,9 @@ function matchSignposting(sentence) {
     if (formulaicSetup !== undefined) {
         return { kind: "formulaic-content-setup", signal: formulaicSetup };
     }
+    if (stripped.startsWith("the fun part is:") && !concreteImplementation) {
+        return { kind: "frame-signpost", signal: "the fun part is:" };
+    }
     const checks = [
         ["transition", TRANSITION_PATTERNS],
         ["consultation-signpost", CONSULTATION_PATTERNS],

package/dist/rules/syntactic-patterns/lead-ins/private/discourse-evaluation.js

@@ -1,4 +1,74 @@
 const ABSTRACT_FRAME_VERBS = ["is", "are", "was", "were"];
+const DISCOURSE_WORK_TAILS = [
+    ["doing", "real", "work"],
+    ["load", "bearing"]
+];
+const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const FRAME_ADJECTIVES = new Set([
+    "basic",
+    "best",
+    "better",
+    "biggest",
+    "bigger",
+    "central",
+    "clearest",
+    "core",
+    "easiest",
+    "final",
+    "first",
+    "hardest",
+    "honest",
+    "important",
+    "main",
+    "only",
+    "obvious",
+    "practical",
+    "real",
+    "simple",
+    "useful"
+]);
+const FRAME_NOUNS = new Set([
+    "answer",
+    "approach",
+    "audit",
+    "challenge",
+    "choice",
+    "conclusion",
+    "diagnosis",
+    "fact",
+    "fix",
+    "focus",
+    "frame",
+    "idea",
+    "lesson",
+    "move",
+    "path",
+    "point",
+    "principle",
+    "priority",
+    "problem",
+    "question",
+    "result",
+    "rule",
+    "shift",
+    "signal",
+    "strategy",
+    "test",
+    "thing",
+    "tradeoff",
+    "truth",
+    "version",
+    "way",
+    "win"
+]);
+const VAGUE_FRAME_VERBS = new Set(["begins", "happens", "lives", "starts"]);
+const VAGUE_FRAME_LOCATIONS = new Set([
+    "downstream",
+    "earlier",
+    "here",
+    "there",
+    "upstream"
+]);
 const EVALUATION_TAILS = new Set([
     "boring",
     "clear",
@@ -72,15 +142,90 @@ function isDiscourseEvaluationSubject(first, subject) {
     }
     return subject.some((word) => DISCOURSE_SUBJECT_HEADS.has(word));
 }
-export function matchDiscourseEvaluationFrame(words) {
-    const [first] = words;
-    if (words.length > 8 ||
-        !["the", "this", "that", "it"].includes(first ?? "")) {
+function matchDiscourseWorkClaim(words, verbIndex, subject) {
+    if (verbIndex <= 0 ||
+        words[verbIndex] !== "is" ||
+        !DISCOURSE_SUBJECT_HEADS.has(subject.at(-1) ?? "")) {
+        return undefined;
+    }
+    const tail = DISCOURSE_WORK_TAILS.find((candidate) => candidate.every((word, index) => words[verbIndex + index + 1] === word));
+    return tail === undefined ? undefined : `is-${tail.join("-")}`;
+}
+function frameNounIndex(words) {
+    if (FRAME_NOUNS.has(words[1] ?? "")) {
+        return 1;
+    }
+    return FRAME_ADJECTIVES.has(words[1] ?? "") && FRAME_NOUNS.has(words[2] ?? "")
+        ? 2
+        : -1;
+}
+function matchWorthAttentionFrame(words) {
+    if (words[0] !== "the") {
         return undefined;
     }
+    const nounIndex = frameNounIndex(words);
+    if (nounIndex < 0 || words[nounIndex + 1] !== "worth") {
+        return undefined;
+    }
+    const tail = words.slice(nounIndex + 2);
+    const matches = tail[0] === "noticing" ||
+        tail[0] === "watching" ||
+        tail[0] === "tracking" ||
+        (tail[0] === "caring" && tail[1] === "about") ||
+        (tail[0] === "paying" && tail[1] === "attention" && tail[2] === "to");
+    return matches
+        ? `the-${words.slice(1, nounIndex + 1).join("-")}-worth-attention`
+        : undefined;
+}
+function matchVagueFrameLocation(words) {
+    const [first, adjective, noun, verb, location] = words;
+    return words.length === 5 &&
+        first === "the" &&
+        FRAME_ADJECTIVES.has(adjective ?? "") &&
+        FRAME_NOUNS.has(noun ?? "") &&
+        VAGUE_FRAME_VERBS.has(verb ?? "") &&
+        VAGUE_FRAME_LOCATIONS.has(location ?? "")
+        ? `the-${adjective ?? "useful"}-${noun ?? "frame"}-${verb ?? "starts"}-${location ?? "here"}`
+        : undefined;
+}
+function matchEvaluativeFrame(words) {
+    const [first, adjective, noun, verb] = words;
+    return first !== undefined &&
+        adjective !== undefined &&
+        noun !== undefined &&
+        verb !== undefined &&
+        DETERMINERS.has(first) &&
+        FRAME_ADJECTIVES.has(adjective) &&
+        FRAME_NOUNS.has(noun) &&
+        ["is", "are", "was"].includes(verb)
+        ? `the-${adjective}-${noun}-${verb}`
+        : undefined;
+}
+export function isAbstractAuditFrame(words) {
+    return words[0] === "the" && frameNounIndex(words) > 0
+        ? words[frameNounIndex(words)] === "audit"
+        : false;
+}
+export function matchExpandedDiscourseFrame(words) {
+    return (matchWorthAttentionFrame(words) ??
+        matchVagueFrameLocation(words) ??
+        matchEvaluativeFrame(words));
+}
+export function matchDiscourseEvaluationFrame(words) {
+    const [first] = words;
     const verbIndex = words.findIndex((word) => ABSTRACT_FRAME_VERBS.includes(word));
     const tail = words.at(-1);
     const subject = verbIndex > 0 ? words.slice(0, verbIndex) : [];
+    const workClaim = matchDiscourseWorkClaim(words, verbIndex, subject);
+    if (workClaim !== undefined) {
+        return workClaim;
+    }
+    if (words.length > 8) {
+        return undefined;
+    }
+    if (!["the", "this", "that", "it"].includes(first ?? "")) {
+        return undefined;
+    }
     return verbIndex > 0 &&
         tail !== undefined &&
         EVALUATION_TAILS.has(tail) &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",