@evomap/evolver-core 2.0.0-beta.18 → 2.0.0-beta.19

package/dist/strategy/constraintAblation.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { classifyProvidedTargetPrefix } from './constraintAblationPredicates.js';
 import { redactString, scanForLeaks } from '../hub/sanitize.js';
 const KEY_VALUE_SECRET_RE = /\b(?:api[_-]?key|token|secret)\s*[:=]\s*(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;]+)/gi;
 const OPENAI_SECRET_RE = /\bsk-[A-Za-z0-9_-]+\b/gi;
@@ -821,357 +822,129 @@ function hasIndependentSimplePastAction(segment, actionForms, inheritsSubject =
     }
     return false;
 }
-function hasPotentialConditionalScope(segment, actionForms, targetActionForms, terms) {
-    const providedTargetPrefixKind = (source) => {
-        const normalizedSource = normalize(source);
-        const objectTerms = terms.filter((term) => !term.verb);
-        if (!normalizedSource || objectTerms.length === 0)
-            return 'none';
-        const stream = lexRequiredEvidence(normalizedSource);
-        const requiredObjectMatches = Math.min(2, objectTerms.length);
-        const objectForms = objectTerms.map((term) => ({
-            forms: targetTermForms(term, 'must_not'),
-            term,
-        }));
-        const matchedObjectTerms = new Set();
-        const matchedObjectIndexes = new Set();
-        let objectPrefixEnd = -1;
-        objectPrefix: for (let index = 0; index < stream.tokens.length; index += 1) {
-            const value = stream.tokens[index]?.value ?? '';
-            for (const candidate of objectForms) {
-                if (matchedObjectTerms.has(candidate.term) || !candidate.forms.has(value))
-                    continue;
-                matchedObjectTerms.add(candidate.term);
-                matchedObjectIndexes.add(index);
-                if (matchedObjectTerms.size >= requiredObjectMatches) {
-                    objectPrefixEnd = index;
-                    break objectPrefix;
-                }
-            }
-        }
-        if (objectPrefixEnd < 0)
-            return 'none';
-        const nonObjectPrefix = stream.tokens
-            .slice(0, objectPrefixEnd + 1)
-            .filter((_, index) => !matchedObjectIndexes.has(index))
-            .map((token) => token.value)
-            .join(' ');
-        if (finiteClauseSubjectPolarity(nonObjectPrefix) !== 'absent'
-            || hasIndependentAffirmativeAction(nonObjectPrefix, actionForms))
-            return 'conditional';
-        // A leading "provided" is ambiguous; walk bounded tail structures and keep unknown shapes conditional.
-        const skipProvidedModifiers = (initialIndex) => {
-            let index = initialIndex;
-            while (index < stream.tokens.length) {
-                const term = stream.tokens[index]?.value ?? '';
-                if (!LEADING_CLAUSE_MODIFIER_TERMS.has(term)
-                    && !PROVIDED_OBJECT_TRAILING_MODIFIER_TERMS.has(term)
-                    && !/ly$/u.test(term))
-                    break;
-                index += 1;
-            }
-            return index;
-        };
-        const consumeRemainingObjectTerms = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            const remaining = new Set(objectForms.filter((candidate) => !matchedObjectTerms.has(candidate.term)));
-            while (index < stream.tokens.length) {
-                const candidate = [...remaining].find((entry) => (entry.forms.has(stream.tokens[index]?.value ?? '')));
-                if (!candidate)
-                    break;
-                remaining.delete(candidate);
-                index = skipProvidedModifiers(index + 1);
-            }
-            return index;
-        };
-        const isProvidedPastPredicate = (term) => (term.endsWith('ed')
-            || IRREGULAR_SIMPLE_PAST_FORMS.has(term)
-            || IRREGULAR_PAST_PARTICIPLE_FORMS.has(term));
-        const consumeProvidedNominal = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            if (SUBJECT_ARTICLE_TERMS.has(stream.tokens[index]?.value ?? ''))
-                index += 1;
-            while (index + 1 < stream.tokens.length) {
-                const term = stream.tokens[index]?.value ?? '';
-                if (!isAttributiveTargetModifier(term)
-                    && !PROVIDED_OBJECT_NOMINAL_MODIFIER_TERMS.has(term))
-                    break;
-                index += 1;
-            }
-            if (index < stream.tokens.length)
-                index += 1;
-            return skipProvidedModifiers(index);
-        };
-        const isProvidedObjectForm = (term) => objectForms.some((candidate) => (candidate.forms.has(term)));
-        const isProvidedMatrixPredicate = (term) => (PROVIDED_OBJECT_MATRIX_PREDICATE_TERMS.has(term)
-            || isFinitePredicateTerm(term)
-            || (actionForms.has(term) && !isProvidedObjectForm(term)));
-        const isProvidedNominalHead = (term) => (PROVIDED_OBJECT_NOMINAL_HEAD_TERMS.has(term) || isProvidedObjectForm(term));
-        const isProvidedNominalModifier = (term) => (isAttributiveTargetModifier(term)
-            || PROVIDED_OBJECT_NOMINAL_MODIFIER_TERMS.has(term)
-            || isProvidedObjectForm(term));
-        const reachesKnownProvidedNominalHead = (initialIndex, genericModifierBudget) => {
-            let index = initialIndex;
-            while (index < stream.tokens.length) {
-                const term = stream.tokens[index]?.value ?? '';
-                if (isProvidedNominalHead(term))
-                    return true;
-                if (!isProvidedNominalModifier(term)) {
-                    if (genericModifierBudget <= 0)
-                        return false;
-                    genericModifierBudget -= 1;
-                }
-                index = skipProvidedModifiers(index + 1);
-            }
-            return false;
-        };
-        const isProvidedMatrixNominalCollocation = (initialIndex) => {
-            const modifier = stream.tokens[initialIndex]?.value ?? '';
-            let index = skipProvidedModifiers(initialIndex + 1);
-            while (index < stream.tokens.length) {
-                const term = stream.tokens[index]?.value ?? '';
-                if (isProvidedNominalHead(term)) {
-                    return PROVIDED_OBJECT_MATRIX_NOMINAL_COLLOCATIONS.has(`${modifier}:${term}`);
-                }
-                if (!isProvidedNominalModifier(term))
-                    return false;
-                index = skipProvidedModifiers(index + 1);
-            }
+function providedTargetPrefixKind(source, context) {
+    const objectTerms = context.terms.filter((term) => !term.verb);
+    return classifyProvidedTargetPrefix({
+        actionForms: context.actionForms,
+        lexicon: {
+            commaDelimitedPrepositions: COMMA_DELIMITED_PREPOSITION_TERMS,
+            conditionalMarkers: CONDITIONAL_MARKER_TERMS,
+            irregularPastParticiples: IRREGULAR_PAST_PARTICIPLE_FORMS,
+            irregularSimplePast: IRREGULAR_SIMPLE_PAST_FORMS,
+            leadingClauseModifiers: LEADING_CLAUSE_MODIFIER_TERMS,
+            passiveAuxiliaries: PASSIVE_AUXILIARY_TERMS,
+            subjectArticles: SUBJECT_ARTICLE_TERMS,
+        },
+        objectForms: objectTerms.map((term) => targetTermForms(term, 'must_not')),
+        predicates: {
+            finiteClauseSubjectPolarity,
+            hasIndependentAffirmativeAction,
+            isAttributiveTargetModifier,
+            isFinitePredicateTerm,
+            tokenize: lexRequiredEvidence,
+        },
+        source: normalize(source),
+    });
+}
+function hasTargetActionPrefix(source, targetActionForms) {
+    const stream = lexRequiredEvidence(source);
+    for (let actionIndex = 0; actionIndex < stream.tokens.length; actionIndex += 1) {
+        if (!targetActionForms.has(stream.tokens[actionIndex]?.value ?? ''))
+            continue;
+        if (actionIndex === 0 || leadingSubjectPolarity(stream, 0, actionIndex) === 'positive')
+            return true;
+    }
+    return false;
+}
+function hasProvidedMatrixAction(source, context) {
+    const commaIndex = source.indexOf(',');
+    if (commaIndex >= 0) {
+        const prefixKind = providedTargetPrefixKind(source.slice(0, commaIndex), context);
+        if (prefixKind === 'factual')
             return false;
-        };
-        const consumeProvidedNominalPhrase = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            const hadArticle = SUBJECT_ARTICLE_TERMS.has(stream.tokens[index]?.value ?? '');
-            if (hadArticle)
-                index += 1;
-            let sawPrenominalModifier = false;
-            let genericPrenominalModifiers = 0;
-            const genericPrenominalLimit = hadArticle ? 2 : 1;
-            while (index + 1 < stream.tokens.length) {
-                const term = stream.tokens[index]?.value ?? '';
-                const nextIndex = skipProvidedModifiers(index + 1);
-                const next = stream.tokens[nextIndex]?.value ?? '';
-                if (nextIndex >= stream.tokens.length
-                    || PROVIDED_OBJECT_RELATIVE_TERMS.has(next)
-                    || CONDITIONAL_MARKER_TERMS.has(next)
-                    || PROVIDED_OBJECT_FACTUAL_TAIL_PREFIX_TERMS.has(next)
-                    || SUBJECT_ARTICLE_TERMS.has(next)
-                    || (isProvidedMatrixPredicate(next)
-                        && !isProvidedMatrixNominalCollocation(nextIndex)))
-                    break;
-                const genericBeforeKnownHead = genericPrenominalModifiers < genericPrenominalLimit
-                    && !isProvidedNominalHead(term)
-                    && reachesKnownProvidedNominalHead(nextIndex, genericPrenominalLimit - genericPrenominalModifiers - 1);
-                const modifier = isProvidedNominalModifier(term)
-                    || genericBeforeKnownHead;
-                if (!modifier)
-                    break;
-                if (!isProvidedNominalModifier(term))
-                    genericPrenominalModifiers += 1;
-                sawPrenominalModifier = true;
-                index = nextIndex;
-            }
-            const head = stream.tokens[index]?.value ?? '';
-            if (!head
-                || PROVIDED_OBJECT_RELATIVE_TERMS.has(head)
-                || CONDITIONAL_MARKER_TERMS.has(head)
-                || PROVIDED_OBJECT_FACTUAL_TAIL_PREFIX_TERMS.has(head)
-                || SUBJECT_ARTICLE_TERMS.has(head)
-                || isProvidedMatrixPredicate(head)
-                || (sawPrenominalModifier && !isProvidedNominalHead(head)))
-                return index;
-            index = skipProvidedModifiers(index + 1);
-            while (stream.tokens[index]?.value.endsWith('ing')) {
-                const complementStart = skipProvidedModifiers(index + 1);
-                const complementEnd = consumeProvidedNominalPhrase(complementStart);
-                if (complementEnd <= complementStart)
-                    break;
-                index = complementEnd;
-            }
-            return index;
-        };
-        const consumeProvidedTerminalNominal = (initialIndex) => {
-            const nominalEnd = consumeProvidedNominalPhrase(initialIndex);
-            if (nominalEnd >= stream.tokens.length)
-                return nominalEnd;
-            const rejectedHead = stream.tokens[nominalEnd]?.value ?? '';
-            let prefixIndex = skipProvidedModifiers(initialIndex);
-            if (SUBJECT_ARTICLE_TERMS.has(stream.tokens[prefixIndex]?.value ?? '')) {
-                prefixIndex = skipProvidedModifiers(prefixIndex + 1);
-            }
-            while (prefixIndex < nominalEnd
-                && !isProvidedNominalHead(stream.tokens[prefixIndex]?.value ?? '')) {
-                prefixIndex = skipProvidedModifiers(prefixIndex + 1);
-            }
-            return isProvidedNominalHead(rejectedHead)
-                && prefixIndex === nominalEnd
-                && skipProvidedModifiers(nominalEnd + 1) >= stream.tokens.length
-                ? stream.tokens.length
-                : nominalEnd;
-        };
-        const classifyProvidedRelativeTail = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            const first = stream.tokens[index]?.value ?? '';
-            if (SUBJECT_ARTICLE_TERMS.has(first)) {
-                index = consumeProvidedNominal(index);
-            }
-            else if (!isProvidedPastPredicate(first)
-                && !PASSIVE_AUXILIARY_TERMS.has(first)
-                && isProvidedPastPredicate(stream.tokens[index + 1]?.value ?? '')) {
-                index = skipProvidedModifiers(index + 1);
-            }
-            while (PASSIVE_AUXILIARY_TERMS.has(stream.tokens[index]?.value ?? '')) {
-                index = skipProvidedModifiers(index + 1);
-            }
-            const predicate = stream.tokens[index]?.value ?? '';
-            if (!isProvidedPastPredicate(predicate))
-                return 'conditional';
-            index = skipProvidedModifiers(index + 1);
-            if (index >= stream.tokens.length)
-                return 'factual';
-            return consumeProvidedTerminalNominal(index) >= stream.tokens.length ? 'factual' : 'conditional';
-        };
-        const classifyProvidedSubordinateTail = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            if (index >= stream.tokens.length)
-                return 'factual';
-            if (isProvidedPastPredicate(stream.tokens[index]?.value ?? '')) {
-                index = skipProvidedModifiers(index + 1);
-                if (index >= stream.tokens.length)
-                    return 'factual';
-            }
-            return consumeProvidedTerminalNominal(index) >= stream.tokens.length ? 'factual' : 'conditional';
-        };
-        const classifyProvidedObjectTail = (initialIndex) => {
-            let index = skipProvidedModifiers(initialIndex);
-            if (index >= stream.tokens.length)
-                return 'factual';
-            const term = stream.tokens[index]?.value ?? '';
-            if (PROVIDED_OBJECT_COORDINATOR_TERMS.has(term)) {
-                index = skipProvidedModifiers(index + 1);
-                if (index >= stream.tokens.length)
-                    return 'factual';
-                const coordinatedTerm = stream.tokens[index]?.value ?? '';
-                const subjectElidedPastAction = actionForms.has(coordinatedTerm)
-                    && isProvidedPastPredicate(coordinatedTerm);
-                if (subjectElidedPastAction) {
-                    index = skipProvidedModifiers(index + 1);
-                    if (index >= stream.tokens.length)
-                        return 'factual';
-                    if (COMMA_DELIMITED_PREPOSITION_TERMS.has(stream.tokens[index]?.value ?? '')) {
-                        return classifyProvidedObjectTail(index);
-                    }
-                }
-                return classifyProvidedObjectTail(consumeProvidedTerminalNominal(index));
-            }
-            if (PROVIDED_OBJECT_RELATIVE_TERMS.has(term))
-                return classifyProvidedRelativeTail(index + 1);
-            if (COMMA_DELIMITED_PREPOSITION_TERMS.has(term)) {
-                return classifyProvidedObjectTail(consumeProvidedTerminalNominal(index + 1));
-            }
-            if (CONDITIONAL_MARKER_TERMS.has(term))
-                return 'conditional';
-            if (PROVIDED_OBJECT_SUBORDINATOR_TERMS.has(term)) {
-                return classifyProvidedSubordinateTail(index + 1);
-            }
-            if (PROVIDED_OBJECT_FACTUAL_TAIL_PREFIX_TERMS.has(term))
-                return 'factual';
-            if (term.endsWith('ing')) {
-                return classifyProvidedObjectTail(consumeProvidedTerminalNominal(index + 1));
-            }
-            return 'conditional';
-        };
-        return classifyProvidedObjectTail(consumeRemainingObjectTerms(objectPrefixEnd + 1));
-    };
-    const hasTargetActionPrefix = (source) => {
-        const stream = lexRequiredEvidence(source);
-        for (let actionIndex = 0; actionIndex < stream.tokens.length; actionIndex += 1) {
-            if (!targetActionForms.has(stream.tokens[actionIndex]?.value ?? ''))
-                continue;
-            if (actionIndex === 0 || leadingSubjectPolarity(stream, 0, actionIndex) === 'positive')
-                return true;
-        }
-        return false;
-    };
-    const hasProvidedMatrixAction = (source) => {
-        // Restrict disambiguation to the immediate consequent, not a later factual clause.
-        const commaIndex = source.indexOf(',');
-        if (commaIndex >= 0) {
-            const prefixKind = providedTargetPrefixKind(source.slice(0, commaIndex));
-            if (prefixKind === 'factual')
-                return false;
-            if (prefixKind === 'conditional')
-                return true;
-        }
-        let matrixScope = commaIndex >= 0
-            ? source.slice(commaIndex + 1)
-            : source.replace(/^\s*that\b/iu, ' ');
-        const subordinateIndex = matrixScope.search(/\b(?:after|assuming|because|before|if|once|supposing|that|unless|when|while)\b/iu);
-        if (subordinateIndex >= 0)
-            matrixScope = matrixScope.slice(0, subordinateIndex);
-        const candidates = matrixScope.split(/\b(?:and|but|or|then)\b/iu);
-        return (commaIndex >= 0 ? candidates : candidates.slice(0, 1))
-            .some((candidate) => hasIndependentAffirmativeAction(candidate, targetActionForms));
-    };
-    const hasPotentialMarker = (source) => {
-        const normalizedSource = source
-            .replace(CLOSED_IF_ANYTHING_RE, '$1 ')
-            .replace(COORDINATED_PROVIDED_RE, (match, connector, offset, whole) => (!targetActionForms.has('provided')
-            || hasTargetActionPrefix(whole.slice(0, offset))
-            || hasProvidedMatrixAction(whole.slice(offset + match.length))
-            ? match
-            : `${connector} `))
-            .replace(LEADING_PROVIDED_RE, (match, boundary, offset, whole) => (!targetActionForms.has('provided')
-            || hasTargetActionPrefix(whole.slice(0, offset))
-            || hasProvidedMatrixAction(whole.slice(offset + match.length))
-            ? match
-            : `${boundary} `));
-        return POTENTIAL_CONDITIONAL_SCOPE_RE.test(normalizedSource)
-            || hasTargetActionBeforePostposedConditionalMarker(normalizedSource, targetActionForms);
-    };
-    const hasFactualProvidedAction = (source) => {
-        const stream = lexRequiredEvidence(source);
-        for (let index = 0; index < stream.tokens.length; index += 1) {
-            const token = stream.tokens[index];
-            if (token?.value !== 'provided' || isAdjectivalProvided(stream.tokens, index))
-                continue;
-            let clauseStart = index;
-            while (clauseStart > 0 && stream.tokens[clauseStart - 1]?.clause === token.clause)
-                clauseStart -= 1;
-            if (leadingSubjectPolarity(stream, clauseStart, index) !== 'positive')
-                continue;
-            const tail = stream.tokens.slice(index + 1)
-                .filter((candidate) => candidate.clause === token.clause)
-                .map((candidate) => candidate.value)
-                .join(' ');
-            if (!hasProvidedMatrixAction(tail))
-                return true;
-        }
-        return false;
-    };
-    if (!hasPotentialMarker(segment))
-        return false;
-    const hadProvidedBy = segment.search(PROVIDED_BY_ADJUNCT_RE) >= 0;
+        if (prefixKind === 'conditional')
+            return true;
+    }
+    let matrixScope = commaIndex >= 0
+        ? source.slice(commaIndex + 1)
+        : source.replace(/^\s*that\b/iu, ' ');
+    const subordinateIndex = matrixScope.search(/\b(?:after|assuming|because|before|if|once|supposing|that|unless|when|while)\b/iu);
+    if (subordinateIndex >= 0)
+        matrixScope = matrixScope.slice(0, subordinateIndex);
+    const candidates = matrixScope.split(/\b(?:and|but|or|then)\b/iu);
+    return (commaIndex >= 0 ? candidates : candidates.slice(0, 1))
+        .some((candidate) => hasIndependentAffirmativeAction(candidate, context.targetActionForms));
+}
+function hasPotentialMarker(source, context) {
+    const { targetActionForms } = context;
+    const normalizedSource = source
+        .replace(CLOSED_IF_ANYTHING_RE, '$1 ')
+        .replace(COORDINATED_PROVIDED_RE, (match, connector, offset, whole) => (!targetActionForms.has('provided')
+        || hasTargetActionPrefix(whole.slice(0, offset), targetActionForms)
+        || hasProvidedMatrixAction(whole.slice(offset + match.length), context)
+        ? match
+        : `${connector} `))
+        .replace(LEADING_PROVIDED_RE, (match, boundary, offset, whole) => (!targetActionForms.has('provided')
+        || hasTargetActionPrefix(whole.slice(0, offset), targetActionForms)
+        || hasProvidedMatrixAction(whole.slice(offset + match.length), context)
+        ? match
+        : `${boundary} `));
+    return POTENTIAL_CONDITIONAL_SCOPE_RE.test(normalizedSource)
+        || hasTargetActionBeforePostposedConditionalMarker(normalizedSource, targetActionForms);
+}
+function hasFactualProvidedAction(source, context) {
+    const stream = lexRequiredEvidence(source);
+    for (let index = 0; index < stream.tokens.length; index += 1) {
+        const token = stream.tokens[index];
+        if (token?.value !== 'provided' || isAdjectivalProvided(stream.tokens, index))
+            continue;
+        let clauseStart = index;
+        while (clauseStart > 0 && stream.tokens[clauseStart - 1]?.clause === token.clause)
+            clauseStart -= 1;
+        if (leadingSubjectPolarity(stream, clauseStart, index) !== 'positive')
+            continue;
+        const tail = stream.tokens.slice(index + 1)
+            .filter((candidate) => candidate.clause === token.clause)
+            .map((candidate) => candidate.value)
+            .join(' ');
+        if (!hasProvidedMatrixAction(tail, context))
+            return true;
+    }
+    return false;
+}
+function stripFactualTemporalMarkers(segment, context) {
     let probe = segment.replace(PROVIDED_BY_ADJUNCT_RE, ' ');
     probe = probe.replace(COORDINATED_TEMPORAL_RE, (match, connector, offset) => {
         const prefix = probe.slice(0, offset);
         const suffix = probe.slice(offset + match.length);
-        return hasIndependentSimplePastPredicate(prefix) && hasIndependentSimplePastAction(suffix, actionForms, true)
+        return hasIndependentSimplePastPredicate(prefix)
+            && hasIndependentSimplePastAction(suffix, context.actionForms, true)
             ? `${connector} `
             : match;
     });
     const leadingTemporal = LEADING_DISCOURSE_TEMPORAL_RE.exec(probe);
-    if (leadingTemporal) {
-        const suffix = probe.slice(leadingTemporal[0].length);
-        if (hasIndependentSimplePastAction(suffix, actionForms)
-            || hasFactualProvidedAction(suffix))
-            probe = suffix;
-    }
-    const hasRemainingPotentialMarker = hasPotentialMarker(probe)
-        || hasTargetActionBeforePostposedConditionalMarker(probe, targetActionForms);
-    return hasRemainingPotentialMarker || (hadProvidedBy
-        && !hasFactualProvidedAction(probe)
-        && lexRequiredEvidence(probe).conditional.some(Boolean));
+    if (!leadingTemporal)
+        return probe;
+    const suffix = probe.slice(leadingTemporal[0].length);
+    return hasIndependentSimplePastAction(suffix, context.actionForms)
+        || hasFactualProvidedAction(suffix, context)
+        ? suffix
+        : probe;
+}
+function hasConditionalEvidence(probe, hadProvidedBy, context) {
+    return hasPotentialMarker(probe, context)
+        || hasTargetActionBeforePostposedConditionalMarker(probe, context.targetActionForms)
+        || (hadProvidedBy
+            && !hasFactualProvidedAction(probe, context)
+            && lexRequiredEvidence(probe).conditional.some(Boolean));
+}
+function hasPotentialConditionalScope(segment, actionForms, targetActionForms, terms) {
+    const context = { actionForms, targetActionForms, terms };
+    if (!hasPotentialMarker(segment, context))
+        return false;
+    const hadProvidedBy = segment.search(PROVIDED_BY_ADJUNCT_RE) >= 0;
+    const probe = stripFactualTemporalMarkers(segment, context);
+    return hasConditionalEvidence(probe, hadProvidedBy, context);
 }
 const NON_FACTUAL_MATRIX_AUXILIARIES = new Set([
     'can', 'cannot', "can't", 'could', "couldn't", 'may', 'might', "mightn't", 'must', "mustn't",
@@ -1659,33 +1432,6 @@ const COMMA_DELIMITED_PREPOSITION_TERMS = new Set([
     ...PASSIVE_SUBJECT_POSTMODIFIER_TERMS,
     'according', 'despite', 'during', 'inside', 'outside', 'regarding', 'within',
 ]);
-const PROVIDED_OBJECT_FACTUAL_TAIL_PREFIX_TERMS = new Set([
-    ...COMMA_DELIMITED_PREPOSITION_TERMS,
-    ...PREDICATE_COORDINATOR_TERMS,
-    'after', 'although', 'as', 'because', 'before', 'however', 'since', 'than', 'though',
-    'whereas', 'yet',
-]);
-const PROVIDED_OBJECT_RELATIVE_TERMS = new Set(['that', 'which', 'who']);
-const PROVIDED_OBJECT_SUBORDINATOR_TERMS = new Set(['after', 'as', 'before']);
-// Bare PP tails are POS-ambiguous; keep this bounded to known prenominal forms with paired tests.
-const PROVIDED_OBJECT_NOMINAL_MODIFIER_TERMS = new Set([
-    'access', 'audit', 'backup', 'cold', 'data', 'offline', 'ongoing',
-    'policy', 'remote', 'secure', 'security', 'token',
-]);
-const PROVIDED_OBJECT_NOMINAL_HEAD_TERMS = new Set([
-    'access', 'approval', 'archive', 'audit', 'auditor', 'credentials', 'data', 'details',
-    'leak', 'leaks', 'metadata', 'policy', 'receipt', 'records', 'request', 'review', 'server',
-    'storage', 'system', 'transit',
-]);
-const PROVIDED_OBJECT_MATRIX_NOMINAL_COLLOCATIONS = new Set(['access:policy']);
-const PROVIDED_OBJECT_COORDINATOR_TERMS = new Set(['and', 'or', 'then']);
-const PROVIDED_OBJECT_TRAILING_MODIFIER_TERMS = new Set([
-    'earlier', 'here', 'now', 'soon', 'today', 'tonight', 'there', 'yesterday',
-]);
-const PROVIDED_OBJECT_MATRIX_PREDICATE_TERMS = new Set([
-    'arrive', 'arrives', 'become', 'becomes', 'exist', 'exists', 'expire', 'expires',
-    'leak', 'leaks', 'match', 'matches', 'pass', 'passes', 'remain', 'remains', 'trigger', 'triggers',
-]);
 const TOTALITY_TARGET_MODIFIER_TERMS = new Set([
     'complete', 'entire', 'full', 'partial', 'total', 'whole',
 ]);

package/dist/strategy/constraintAblationPredicates.d.ts

@@ -0,0 +1,31 @@
+type ProvidedPrefixKind = 'conditional' | 'factual' | 'none';
+interface PredicateTokenStream {
+    tokens: readonly {
+        value: string;
+    }[];
+}
+interface ProvidedPrefixLexicon {
+    commaDelimitedPrepositions: ReadonlySet<string>;
+    conditionalMarkers: ReadonlySet<string>;
+    irregularPastParticiples: ReadonlySet<string>;
+    irregularSimplePast: ReadonlySet<string>;
+    leadingClauseModifiers: ReadonlySet<string>;
+    passiveAuxiliaries: ReadonlySet<string>;
+    subjectArticles: ReadonlySet<string>;
+}
+interface ProvidedPrefixPredicates {
+    finiteClauseSubjectPolarity(source: string): 'absent' | 'negative' | 'positive';
+    hasIndependentAffirmativeAction(source: string, actionForms: ReadonlySet<string>): boolean;
+    isAttributiveTargetModifier(term: string): boolean;
+    isFinitePredicateTerm(term: string): boolean;
+    tokenize(source: string): PredicateTokenStream;
+}
+interface ProvidedPrefixInput {
+    actionForms: ReadonlySet<string>;
+    lexicon: ProvidedPrefixLexicon;
+    objectForms: readonly ReadonlySet<string>[];
+    predicates: ProvidedPrefixPredicates;
+    source: string;
+}
+export declare function classifyProvidedTargetPrefix(input: ProvidedPrefixInput): ProvidedPrefixKind;
+export {};