@piagent/platform 1.6.0 → 1.7.1

package/packages/piagent-core/extensions/acceptance-contract-semantics.js

@@ -1,40 +1,31 @@
+import { finiteIntervalRecordEvidence } from "./acceptance-temporal-contract.js";
 import path from "node:path";
-import { acceptanceBoundaryProofGuidance } from "./acceptance-boundary-guidance.js";
-import { evidenceTopLevelArguments, executableRejectionAssertions } from "./acceptance-executable-evidence.js";
-import { ERROR_CONSTRUCTORS, ERROR_CONSTRUCTOR_DISPLAY_NAMES, errorMappingsProveContract,
-  hasAmbiguousErrorClassIntent, rejectionStatementErrorClass, requestedErrorClasses, requestedErrorPartitionMapping } from "./acceptance-error-classes.js";
+import { browserWindowReferencesAreLocal, nativeErrorReferencesAreUnshadowed } from "./acceptance-local-binding.js";
+import { callableBodies } from "./acceptance-callable-scanner.js";
+import { acceptanceIntegerConstraintTargets as integerConstraintTargets } from "./acceptance-contract-conjunction.js";
+import { acceptanceBoundaryProofGuidance, isoTimestampProofGuidance, malformedIdentifierContract, malformedTaggedEventRequirements, rejectionClassProofGuidance } from "./acceptance-boundary-guidance.js";
+import { executableRejectionAssertions } from "./acceptance-executable-evidence.js";
+import { ERROR_CONSTRUCTORS, ERROR_CONSTRUCTOR_DISPLAY_NAMES, errorMappingsProveContract, hasAmbiguousErrorClassIntent, rejectionStatementErrorClass, requestedErrorClasses, requestedErrorPartitionMapping } from "./acceptance-error-classes.js";
+import { inputDerivedNames } from "./acceptance-input-provenance.js";
+import { consumeJavaScriptStringEscape, eraseJavaScriptLexeme as erasedLexeme, isJavaScriptLineTerminator, normalizedJavaScriptLineTerminator, regexLiteralSentinel, stringLiteralSentinel, validJavaScriptRegexLiteral } from "./acceptance-lexical-sentinels.js";
+import { exactNormalizerInvocation, synchronousNormalizerProof } from "./acceptance-normalizer-evidence.js";
+import { casePreservingCallableBodies } from "./acceptance-expiry-calendar-proof.js";
+import { invalidSentinelRejectionProof, withInvalidSentinelDiagnostics } from "./acceptance-invalid-sentinel-proof.js";
 import { statefulTerminalRejectionEvidence } from "./acceptance-state-machine-evidence.js";
+import { malformedTaggedEventEvidence } from "./acceptance-tagged-event-evidence.js";
 import { boundRejectionTestEvidence, callableAssertionMode } from "./acceptance-test-binding-evidence.js";
+import { routeNamedSourceTargets } from "./acceptance-source-origin.js";
+import { rejectedIntegerParameter, integerParameterBindingEvidence, orderedRecordRejectionEvidence, dependencyCycleEvidence } from "./acceptance-parameter-contract.js";
+import { integerDomainEvidence } from "./acceptance-integer-domains.js";
+import { requestedInvalidPartitions } from "./acceptance-invalid-partitions.js";
+import { temporalContractEvidence, temporalInputRequirements } from "./acceptance-temporal-contract.js";
 import { regexCanStartAfterLexicalChunks } from "./javascript-regex-evidence.js";
-const INTEGER_TARGET_STOPWORDS = new Set([
-  "and", "basis", "cents", "input", "inputs", "items", "money", "number", "numbers", "or", "points", "typeerror", "value", "values"
-]);
-
 function normalizedText(value) {
   return String(value ?? "")
     .normalize("NFD")
     .replace(/[\u0300-\u036f]/g, "")
     .toLowerCase();
 }
-
-function erasedLexeme(value) {
-  return String(value ?? "").replace(/[^\r\n]/g, " ");
-}
-
-function stringLiteralSentinel(value) {
-  if (value.length === 0) return "__pi_empty_string_literal__";
-  if (value === '"') return "__pi_double_quote_string_literal__";
-  if (/^(?:\s|\\[nrtvf0])+$/u.test(value)) return "__pi_whitespace_string_literal__";
-  if (["assert", "assert/strict", "node:assert", "node:assert/strict"].includes(value.trim().toLowerCase())) {
-    return "__pi_node_assert_module_literal__";
-  }
-  if (["node:vm", "vm"].includes(value.trim().toLowerCase())) return "__pi_code_generation_module_literal__";
-  if (["module", "node:module"].includes(value.trim().toLowerCase())) return "__pi_module_loader_module_literal__";
-  const errorName = value.trim().toLowerCase().match(/^(typeerror|rangeerror|syntaxerror|referenceerror|urierror|evalerror|aggregateerror|error)$/)?.[1];
-  if (errorName) return `__pi_error_name_${errorName}_literal__`;
-  return "__pi_string_literal__";
-}
-
 /**
  * Return a bounded lexical evidence view of JavaScript/TypeScript source.
  *
@@ -53,16 +44,17 @@ function lexJavaScriptEvidence(value, bindStrings = false) {
   while (index < source.length) {
     const current = source[index];
     const next = source[index + 1];
-
+    if (isJavaScriptLineTerminator(current)) { output.push(normalizedJavaScriptLineTerminator(current)); index += 1; continue; }
     if (current === "/" && next === "/") {
       let end = index + 2;
-      while (end < source.length && source[end] !== "\n" && source[end] !== "\r") end += 1;
+      while (end < source.length && !isJavaScriptLineTerminator(source[end])) end += 1;
       output.push(erasedLexeme(source.slice(index, end)));
       index = end;
       continue;
     }
     if (current === "/" && next === "*") {
       const closing = source.indexOf("*/", index + 2);
+      if (closing === -1) { output.push("__pi_invalid_comment_lexeme__"); index = source.length; continue; }
       const end = closing === -1 ? source.length : closing + 2;
       output.push(erasedLexeme(source.slice(index, end)));
       index = end;
@@ -71,37 +63,42 @@ function lexJavaScriptEvidence(value, bindStrings = false) {
     if (current === "'" || current === '"') {
       const quote = current;
       let end = index + 1;
-      let payload = "";
-      let closed = false;
+      let cooked = "";
+      let closed = false, invalidEscape = false;
       while (end < source.length) {
         const character = source[end];
         if (character === "\\") {
-          payload += source.slice(end, Math.min(source.length, end + 2));
-          end += 2;
+          const consumed = consumeJavaScriptStringEscape(source, end);
+          invalidEscape ||= !consumed.valid;
+          cooked += consumed.cooked;
+          end = consumed.nextIndex;
           continue;
         }
+        if (character === "\n" || character === "\r") break;
         if (character === quote) {
           end += 1;
           closed = true;
           break;
         }
-        payload += character;
+        cooked += character;
         end += 1;
       }
-      if (!closed) output.push(erasedLexeme(source.slice(index, end)));
+      if (!closed) output.push("__pi_invalid_string_lexeme__");
+      else if (invalidEscape) output.push("__pi_invalid_escape_lexeme__");
       else if (bindStrings) {
         output.push(`__pi_bound_string_${strings.length}__`);
-        strings.push(payload);
-      } else output.push(stringLiteralSentinel(payload));
+        strings.push(cooked);
+      } else output.push(stringLiteralSentinel(cooked));
       index = end;
       continue;
     }
     if (current === "`") {
-      let end = index + 1;
-      let closed = false;
+      let end = index + 1, closed = false, invalidEscape = false;
       while (end < source.length) {
         if (source[end] === "\\") {
-          end += 2;
+          const consumed = consumeJavaScriptStringEscape(source, end);
+          invalidEscape ||= !consumed.valid;
+          end = consumed.nextIndex;
           continue;
         }
         if (source[end] === "`") {
@@ -111,17 +108,18 @@ function lexJavaScriptEvidence(value, bindStrings = false) {
         }
         end += 1;
       }
-      output.push(closed ? "__pi_template_literal__" : erasedLexeme(source.slice(index, end)));
+      output.push(closed && !invalidEscape ? "__pi_template_literal__" : "__pi_invalid_template_lexeme__");
       index = end;
       continue;
     }
     if (current === "/" && next !== "=" && regexCanStartAfterLexicalChunks(output)) {
-      let end = index + 1;
+      let end = index + 1, payload = "";
       let inClass = false;
       let closed = false;
       while (end < source.length) {
         const character = source[end];
         if (character === "\\") {
+          payload += source.slice(end, Math.min(source.length, end + 2));
           end += 2;
           continue;
         }
@@ -129,19 +127,21 @@ function lexJavaScriptEvidence(value, bindStrings = false) {
         else if (character === "]") inClass = false;
         else if (character === "/" && !inClass) {
           end += 1;
+          const flagsStart = end;
           while (/[a-z]/iu.test(source[end] ?? "")) end += 1;
+          const flags = source.slice(flagsStart, end);
           closed = true;
+          output.push(validJavaScriptRegexLiteral(payload, flags) ? regexLiteralSentinel(payload, flags) : "__pi_invalid_regex_lexeme__");
           break;
-        } else if (character === "\n" || character === "\r") {
+        } else if (isJavaScriptLineTerminator(character)) {
           break;
         }
+        payload += character;
         end += 1;
       }
-      if (closed) {
-        output.push("__pi_regex_literal__");
-        index = end;
-        continue;
-      }
+      if (!closed) output.push("__pi_invalid_regex_lexeme__");
+      index = end;
+      continue;
     }
     output.push(current);
     index += 1;
@@ -149,16 +149,13 @@ function lexJavaScriptEvidence(value, bindStrings = false) {
   const code = output.join("");
   return bindStrings ? { code, strings } : code;
 }
-
 export function sanitizeJavaScriptEvidence(value) {
   return lexJavaScriptEvidence(value, false);
 }
-
 function uniqueStrings(values) {
   return [...new Set((Array.isArray(values) ? values : []).filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim()))];
 }
 function hasReservedEvidenceIdentifier(value) { return /\b__pi_[a-z0-9_]*\b/i.test(String(value ?? "")); }
-
 function escapeRegex(value) {
   return String(value ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -175,18 +172,6 @@ function integerGuardHelpers(sourceText) {
   return uniqueStrings(helpers).slice(0, 12);
 }
 
-function integerConstraintTargets(text, sourceText = "") {
-  const value = normalizedText(text);
-  const source = normalizedText(sourceText);
-  const candidates = [];
-  for (const match of value.matchAll(/\b(?:an?\s+)?(?:non-negative\s+|positive\s+)?integer\s+([a-z_$][a-z0-9_$]*)\b/g)) candidates.push(match[1]);
-  for (const match of value.matchAll(/`([a-z_$][a-z0-9_$]*)`[^.\n]{0,120}\b(?:is|must be|must remain)\s+(?:an?\s+)?(?:non-negative\s+|positive\s+)?(?:safe\s+)?integer\b/g)) candidates.push(match[1]);
-  return uniqueStrings(candidates)
-    .map((item) => item.toLowerCase())
-    .filter((item) => !INTEGER_TARGET_STOPWORDS.has(item))
-    .filter((item) => !source || new RegExp(`\\b${escapeRegex(item)}\\b`).test(source));
-}
-
 function onlyUndefinedContract(text) {
   const value = normalizedText(text);
   return /\babsent\s+only\s+when[^.\n]{0,80}\bundefined\b/.test(value)
@@ -255,7 +240,7 @@ function entryPath(value) {
   return path.posix.normalize(String(value ?? "").replace(/\\/g, "/").replace(/^\.\//, ""));
 }
 
-function sourceExports(entry) {
+export function sourceExports(entry) {
   const code = normalizedText(sanitizeJavaScriptEvidence(entry?.text ?? entry?.evidenceText));
   const exports = [];
   for (const match of code.matchAll(/\bexport\s+(?:async\s+)?function\s+([a-z_$][a-z0-9_$]*)\b/g)) exports.push({ contractName: match[1], exportName: match[1], sourceName: match[1] });
@@ -384,7 +369,7 @@ function intrinsicErrorBindingsUntampered(code, errorNames) {
 }
 
 function lexicalEvidenceIsNonReflective(code) {
-  return !/\\|__pi_(?:code_generation|module_loader)_module_literal__|\b(?:eval|createrequire)\b|\b(?:process|globalthis|global|window|self|this)\b|\.\s*constructor\b|\bfunction\s*\(|(?:=|[,([])\s*function\b(?!\s+[a-z_$][a-z0-9_$]*\s*\()/i.test(code);
+  return browserWindowReferencesAreLocal(code) && !/__pi_invalid_[a-z0-9_]*lexeme__|\\|__pi_(?:code_generation|module_loader)_module_literal__|\b(?:eval|createrequire)\b|\b(?:process|globalthis|global|self|this)\b|\.\s*constructor\b|\bfunction\s*\(|(?:=|[,([])\s*function\b(?!\s+[a-z_$][a-z0-9_$]*\s*\()/i.test(code);
 }
 
 function resolvedExportTestBindings(sourceEntries, testEntries) {
@@ -405,14 +390,15 @@ function resolvedExportTestBindings(sourceEntries, testEntries) {
   return resolved;
 }
 
-function namedTargetBindings(sourceEntries, testEntries, namedTargets) {
+export function namedTargetBindings(sourceEntries, testEntries, namedTargets) {
   const exports = sourceEntries.flatMap(sourceExports);
   const imports = testEntries.flatMap(staticModuleBindings);
   const entries = new Map(testEntries.map((entry) => [entryPath(entry.path), entry]));
   return namedTargets.map((target) => {
-    const matches = exports.filter((item) => item.contractName === target
-      && sourceCallableBindingIsStable(sourceEntries.find((entry) => entryPath(entry?.path) === item.sourcePath), item.sourceName));
-    if (matches.length !== 1) return { target, sourcePath: null, sourceName: null, testNames: [], testBindings: [] };
+    const matches = exports.filter((item) => item.contractName === target);
+    if (matches.length !== 1 || !sourceCallableBindingIsStable(
+      sourceEntries.find((entry) => entryPath(entry?.path) === matches[0].sourcePath), matches[0].sourceName
+    )) return { target, sourcePath: null, sourceName: null, testNames: [], testBindings: [] };
     const exported = matches[0];
     const testBindings = [];
     for (const binding of imports.filter((item) => importResolvesTo(item, exported.sourcePath))) {
@@ -433,81 +419,6 @@ function namedTargetBindings(sourceEntries, testEntries, namedTargets) {
   });
 }
 
-function formalParameterNames(parameters) {
-  const wrapped = `(${String(parameters ?? "")})`;
-  const names = [];
-  for (const raw of evidenceTopLevelArguments(wrapped, 0, wrapped.length)) {
-    const value = raw.trim().replace(/^(?:public|private|protected|readonly)\s+/, "").replace(/^\.\.\./, "");
-    const direct = value.match(/^([a-z_$][a-z0-9_$]*)\s*(?:[?:=]|$)/i);
-    if (direct) {
-      names.push(direct[1]);
-      continue;
-    }
-    const object = value.match(/^\{([^}]*)\}/)?.[1];
-    if (object) {
-      for (const item of object.split(",")) {
-        const binding = item.trim().match(/^(?:[a-z_$][a-z0-9_$]*\s*:\s*)?([a-z_$][a-z0-9_$]*)/i);
-        if (binding) names.push(binding[1]);
-      }
-      continue;
-    }
-    const array = value.match(/^\[([^\]]*)\]/)?.[1];
-    if (array) names.push(...(array.match(/[a-z_$][a-z0-9_$]*/gi) ?? []));
-  }
-  return uniqueStrings(names).map((item) => item.toLowerCase()).slice(0, 16);
-}
-
-function callableBodies(code) {
-  const bodies = new Map();
-  const addBraced = (name, parameters, open, asynchronous = false) => {
-    const end = evidenceBalancedEnd(code, open, "{", "}");
-    if (end !== -1 && !bodies.has(name)) bodies.set(name, {
-      body: code.slice(open + 1, end - 1),
-      parameters: formalParameterNames(parameters), sourceCode: code, asynchronous
-    });
-  };
-  for (const match of code.matchAll(/\b(?:async\s+)?function\s+([a-z_$][a-z0-9_$]*)\s*\(([^)]*)\)\s*\{/gi)) addBraced(match[1].toLowerCase(), match[2], match.index + match[0].lastIndexOf("{"), /^async\b/i.test(match[0]));
-  for (const match of code.matchAll(/^\s*(?:async\s+)?([a-z_$][a-z0-9_$]*)\s*\(([^)]*)\)\s*\{/gim)) {
-    if (!["catch", "for", "if", "switch", "while", "with"].includes(match[1].toLowerCase())) addBraced(match[1].toLowerCase(), match[2], match.index + match[0].lastIndexOf("{"), /^\s*async\b/i.test(match[0]));
-  }
-  for (const match of code.matchAll(/\b(?:const|let|var)\s+([a-z_$][a-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\(([^)]*)\)|([a-z_$][a-z0-9_$]*))\s*=>\s*/gi)) {
-    const start = match.index + match[0].length;
-    if (code[start] === "{") addBraced(match[1].toLowerCase(), match[2] ?? match[3], start, /=\s*async\b/i.test(match[0]));
-    else bodies.set(match[1].toLowerCase(), {
-      body: code.slice(start, [code.indexOf(";", start), code.indexOf("\n", start)].filter((item) => item >= 0).sort((a, b) => a - b)[0] ?? code.length),
-      parameters: formalParameterNames(match[2] ?? match[3]), sourceCode: code, asynchronous: /=\s*async\b/i.test(match[0])
-    });
-  }
-  return bodies;
-}
-
-function inputDerivedNames(callable) {
-  const derived = new Set(callable.parameters);
-  const declarations = [...callable.body.matchAll(/\bconst\s+([a-z_$][a-z0-9_$]*|\{[^}\n]{1,300}\}|\[[^\]\n]{1,300}\])\s*=\s*([^;\n]{1,1000})/gi)];
-  for (let pass = 0; pass < 4; pass += 1) {
-    let changed = false;
-    for (const match of declarations) {
-      const initializer = match[2];
-      if (/\b(?:process|globalthis)\b|\bimport\.meta\b|\bdate\.now\s*\(|\bmath\.random\s*\(/.test(initializer)) continue;
-      if (![...derived].some((name) => new RegExp(`\\b${escapeRegex(name)}\\b`).test(initializer))) continue;
-      const bindings = match[1].startsWith("{")
-        ? match[1].slice(1, -1).split(",").map((item) => item.trim().match(/^(?:[a-z_$][a-z0-9_$]*\s*:\s*)?([a-z_$][a-z0-9_$]*)/i)?.[1])
-        : match[1].startsWith("[")
-          ? (match[1].match(/[a-z_$][a-z0-9_$]*/gi) ?? [])
-          : [match[1]];
-      for (const binding of bindings.filter(Boolean)) {
-        const normalized = binding.toLowerCase();
-        if (!derived.has(normalized)) {
-          derived.add(normalized);
-          changed = true;
-        }
-      }
-    }
-    if (!changed) break;
-  }
-  return [...derived].slice(0, 24);
-}
-
 function mergeValidationProof(target, candidate) {
   target.generic ||= candidate.generic;
   for (const partition of candidate.partitions) target.partitions.add(partition);
@@ -526,11 +437,18 @@ function positiveValidationConditionProof(condition, names, bodies, visited = ne
       proof.generic = true;
       proof.partitions.add("fractional");
       proof.partitions.add("non-finite");
+      proof.partitions.add("non-finite-number");
       if (integer[1] === "safeinteger") proof.partitions.add("unsafe-integer");
     }
     if (new RegExp(`number\\.isfinite\\s*\\(\\s*${escaped}\\b`).test(condition)) {
       proof.generic = true;
       proof.partitions.add("non-finite");
+      proof.partitions.add("non-finite-number");
+      proof.partitions.add("missing");
+    }
+    if (new RegExp(`typeof\\s+${escaped}\\b\\s*={2,3}\\s*__pi_typeof_(?!undefined_)[a-z]+_literal__`).test(condition)) {
+      proof.generic = true;
+      proof.partitions.add("missing");
     }
     if (new RegExp(`array\\.isarray\\s*\\(\\s*${escaped}\\b`).test(condition)) {
       proof.generic = true;
@@ -602,12 +520,23 @@ function validationConditionProof(condition, names, bodies) {
       || comparison.test(condition);
     if (!validationShape) continue;
     proof.generic = true;
+    if (new RegExp(`number\\.is(?:finite|integer|safeinteger)\\s*\\(\\s*${escaped}\\b`).test(condition)) {
+      proof.partitions.add("non-finite");
+      proof.partitions.add("non-finite-number");
+    }
     if (new RegExp(`!\\s*number\\.is(?:safe)?integer\\s*\\(\\s*${escaped}\\b|number\\.is(?:safe)?integer\\s*\\(\\s*${escaped}[^)]*\\)\\s*(?:===|==)\\s*false|\\b${escaped}\\b\\s*%\\s*1`).test(condition)) {
       proof.partitions.add("fractional");
       proof.partitions.add("non-finite");
+      proof.partitions.add("non-finite-number");
     }
     if (new RegExp(`!\\s*number\\.issafeinteger\\s*\\(\\s*${escaped}\\b`).test(condition)) proof.partitions.add("unsafe-integer");
-    if (new RegExp(`!\\s*number\\.isfinite\\s*\\(\\s*${escaped}\\b`).test(condition)) proof.partitions.add("non-finite");
+    if (new RegExp(`!\\s*number\\.isfinite\\s*\\(\\s*${escaped}\\b`).test(condition)) {
+      proof.partitions.add("non-finite");
+      proof.partitions.add("non-finite-number");
+    }
+    if (new RegExp(`typeof\\s+${escaped}\\b\\s*!={1,2}\\s*__pi_typeof_(?!undefined_)[a-z]+_literal__`).test(condition)) {
+      proof.partitions.add("missing");
+    }
     if (new RegExp(`\\b${escaped}\\b\\s*(?:<\\s*[01]|<=\\s*0)|0\\s*>\\s*\\b${escaped}\\b|\\b${escaped}\\b\\s*<=\\s*-\\d|!\\s*\\(?\\s*\\b${escaped}\\b\\s*>=\\s*0`).test(condition)) proof.partitions.add("negative");
     if (new RegExp(`\\b${escaped}\\b\\s*(?:===|==|<=)\\s*0|\\b${escaped}\\b\\s*<\\s*1|!\\s*\\b${escaped}\\b`).test(condition)) proof.partitions.add("zero");
     if (new RegExp(`\\b${escaped}\\b\\s*(?:===|==)\\s*null|null\\s*(?:===|==)\\s*\\b${escaped}\\b|!\\s*\\b${escaped}\\b`).test(condition)) proof.partitions.add("null");
@@ -711,9 +640,10 @@ function inputNameWrittenBefore(callable, name, offset) {
   return new RegExp(`(?:\\+\\+|--)\\s*\\b${escaped}\\b`, "i").test(prefix);
 }
 
-function conditionalRejection(callable, requestedErrors, bodies, contractText = "", contractTarget = "") {
+function conditionalRejection(callable, requestedErrors, bodies, contractText = "", contractTarget = "", requiredInputNames = null) {
   const proof = { generic: false, partitions: new Set(), errorMappings: [] };
-  const names = inputDerivedNames(callable);
+  const seeds = Array.isArray(requiredInputNames) && requiredInputNames.length > 0 ? requiredInputNames : callable.parameters;
+  const names = inputDerivedNames(callable, seeds);
   for (const match of callable.body.matchAll(/\bif\s*\(/g)) {
     if (sourceBraceDepthAt(callable.body, match.index) !== 0 || priorUnconditionalExit(callable.body, match.index)) continue;
     const conditionOpen = callable.body.indexOf("(", match.index);
@@ -749,72 +679,83 @@ function conditionalRejection(callable, requestedErrors, bodies, contractText =
       for (const partition of validation.partitions) proof.errorMappings.push({ partition, errorClass: followingError });
     }
   }
-  proof.generic ||= statefulTerminalRejectionEvidence(callable.body, callable.parameters, requestedErrors, contractText, contractTarget, callable.sourceCode);
+  proof.generic ||= statefulTerminalRejectionEvidence(callable.body, seeds, requestedErrors, contractText, contractTarget, callable.sourceCode);
   return { ...proof, names };
 }
 function sourceCallableProvesErrorMapping(bodies, name, mapping) {
   const observed = sourceCallableProof(bodies, name, []).errorMappings ?? [];
   return errorMappingsProveContract(observed, mapping);
 }
-function sourceCallableProof(bodies, name, requestedErrors, visited = new Set(), contractText = "", contractTarget = name) {
+function sourceCallableProof(bodies, name, requestedErrors, visited = new Set(), contractText = "", contractTarget = name, requiredInputNames = null, omissionSensitiveInputNames = [], requestedPartitions = []) {
   if (visited.has(name) || visited.size >= 12) return { generic: false, partitions: new Set() };
   const callable = bodies.get(name);
   if (!callable) return { generic: false, partitions: new Set() };
-  const proof = conditionalRejection(callable, requestedErrors, bodies, contractText, contractTarget);
+  const proof = conditionalRejection(callable, requestedErrors, bodies, contractText, contractTarget, requiredInputNames);
+  mergeValidationProof(proof, synchronousNormalizerProof({
+    bodies, name, requestedErrors, requiredInputNames,
+    inputDerivedNames, sourceCallableBindingIsStable, validationConditionProof
+  }));
+  const invalidSentinelProof = invalidSentinelRejectionProof({ bodies, name, requestedErrors, requestedPartitions, requiredInputNames, contractText }); mergeValidationProof(proof, invalidSentinelProof);
+  if (invalidSentinelProof.generic) return { ...proof, preservesExplicitUndefined: invalidSentinelProof.preservesExplicitUndefined === true };
+  if (invalidSentinelProof.candidate) return { generic: false, partitions: new Set(), errorMappings: [], names: proof.names };
   const nextVisited = new Set(visited).add(name);
   for (const match of callable.body.matchAll(/\b([a-z_$][a-z0-9_$]*)\s*\(/gi)) {
     const helper = match[1].toLowerCase();
-    if (!bodies.has(helper) || !directSourceCall(callable.body, match.index)) continue;
+    if (!bodies.has(helper)) continue;
     const open = callable.body.indexOf("(", match.index);
     const end = evidenceBalancedEnd(callable.body, open);
     const argumentsText = end === -1 ? "" : callable.body.slice(open + 1, end - 1);
-    if (!proof.names.some((candidate) => !inputNameWrittenBefore(callable, candidate, match.index)
-      && new RegExp(`\\b${escapeRegex(candidate)}\\b`).test(argumentsText))) continue;
-    const helperProof = sourceCallableProof(bodies, helper, requestedErrors, nextVisited, contractText, contractTarget);
+    const relevantArguments = proof.names.some((candidate) => !inputNameWrittenBefore(callable, candidate, match.index)
+      && new RegExp(`\\b${escapeRegex(candidate)}\\b`).test(argumentsText));
+    if (!relevantArguments) continue;
+    const directCall = directSourceCall(callable.body, match.index);
+    const invocationInputNames = Array.isArray(requiredInputNames) && requiredInputNames.length > 0 ? requiredInputNames : null;
+    const normalizerInvocation = end === -1 ? { accepted: false, derivedParameters: [] } : exactNormalizerInvocation({
+      callable, matchIndex: match.index, callEnd: end, argumentsText, helper,
+      helperParameters: bodies.get(helper)?.parameters ?? [],
+      inputDerivedNames: invocationInputNames ? (candidate) => inputDerivedNames(candidate, invocationInputNames) : inputDerivedNames,
+      helperBindingIsShadowedInCallable, omissionSensitiveInputNames
+    });
+    const helperParameters = bodies.get(helper)?.parameters ?? [];
+    const candidateProof = synchronousNormalizerProof({
+      bodies, name: helper, requestedErrors, requiredInputNames: normalizerInvocation.derivedParameters,
+      inputDerivedNames, sourceCallableBindingIsStable, validationConditionProof
+    });
+    const normalizerProof = normalizerInvocation.accepted ? candidateProof : { generic: false, partitions: new Set(), candidate: candidateProof.candidate };
+    const normalizerCall = normalizerProof.generic;
+    if (invocationInputNames && candidateProof.candidate && !normalizerCall) {
+      return { generic: false, partitions: new Set(), errorMappings: [], names: proof.names };
+    }
+    const modeledInvocation = directCall || normalizerInvocation.accepted;
+    if (candidateProof.candidate && !normalizerCall && modeledInvocation) {
+      return { generic: false, partitions: new Set(), errorMappings: [], names: proof.names };
+    }
+    if (!modeledInvocation && !normalizerCall) continue;
+    const helperProof = normalizerCall ? normalizerProof
+      : sourceCallableProof(bodies, helper, requestedErrors, nextVisited, contractText, contractTarget,
+        normalizerInvocation.accepted ? normalizerInvocation.derivedParameters : helperParameters, [], requestedPartitions);
+    if (!helperProof.generic) {
+      return { generic: false, partitions: new Set(), errorMappings: [], names: proof.names };
+    }
     proof.generic ||= helperProof.generic;
     for (const partition of helperProof.partitions) proof.partitions.add(partition);
   }
   return proof;
 }
-function sourceCallableProves(bodies, name, requestedErrors, requestedPartitions, contractText = "") {
-  const proof = sourceCallableProof(bodies, name, requestedErrors, new Set(), contractText, name);
-  return proof.generic && requestedPartitions.every((partition) => partitionCovered(partition, proof.partitions));
-}
-
-function evidenceCallableNames(sourceText) {
-  const names = new Set();
-  const ignored = new Set(["catch", "for", "if", "switch", "while", "with"]);
-  for (const match of sourceText.matchAll(/\bfunction\s+([a-z_$][a-z0-9_$]*)\s*\(/gi)) names.add(match[1].toLowerCase());
-  for (const match of sourceText.matchAll(/^\s*(?:async\s+)?([a-z_$][a-z0-9_$]*)\s*\([^)]*\)\s*\{/gim)) {
-    if (!ignored.has(match[1].toLowerCase())) names.add(match[1].toLowerCase());
-  }
-  for (const match of sourceText.matchAll(/\b(?:const|let|var)\s+([a-z_$][a-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-z_$][a-z0-9_$]*)\s*=>/gi)) names.add(match[1].toLowerCase());
-  return names;
-}
-
-function requestedInvalidPartitions(text) {
-  const invalid = normalizedText(text)
-    .split(/(?<=[.!?;])\s+|\n+/)
-    .filter((clause) => /\b(?:invalid|malformed|reject(?:s|ed|ion)?|throw(?:s|ing)?|typeerror|rangeerror|syntaxerror)\b/.test(clause))
-    .join("\n");
-  const partitions = new Set();
-  if (/\bnegative\b/.test(invalid)) partitions.add("negative");
-  if (/\bfractional\b/.test(invalid)) partitions.add("fractional");
-  if (/\bzero\b/.test(invalid)) partitions.add("zero");
-  if (/\bnull\b/.test(invalid)) partitions.add("null");
-  if (/\b(?:empty[- ]string|whitespace-only|string[^.\n]{0,80}non-whitespace)\b/.test(invalid)) partitions.add("empty-string");
-  if (/\bwhitespace-only\b/.test(invalid)) partitions.add("whitespace-string");
-  if (/\bnon-finite\b/.test(invalid)) partitions.add("non-finite");
-  if (/\bunsafe[- ]integer\b/.test(invalid)) partitions.add("unsafe-integer");
-  if (/\b(?:missing|undefined)\b/.test(invalid)) partitions.add("missing");
-  if (/\bnon-array\b/.test(invalid)) partitions.add("non-array");
-  if (/\bnon-string\b/.test(invalid)) partitions.add("non-string");
-  if (/\breject(?:s|ed|ing)?\s+(?:an?\s+)?arrays?\b|\barrays?\s+(?:values?\s+)?(?:are|is|must be)\s+(?:invalid|rejected|disallowed|not allowed)\b/.test(invalid)) partitions.add("array");
-  if (/\breject(?:s|ed|ing)?\s+(?:an?\s+)?plain[- ]objects?\b|\bplain[- ]objects?\s+(?:values?\s+)?(?:are|is|must be)\s+(?:invalid|rejected|disallowed|not allowed)\b/.test(invalid)) partitions.add("plain-object");
-  if (/\breject(?:s|ed|ing)?\s+(?:an?\s+)?primitives?\b|\bprimitives?\s+(?:values?\s+)?(?:are|is|must be)\s+(?:invalid|rejected|disallowed|not allowed)\b/.test(invalid)) partitions.add("primitive");
-  return [...partitions];
+function sourceCallableProves(bodies, name, requestedErrors, requestedPartitions, contractText = "", requiredInputNames = null) {
+  const required = Array.isArray(requiredInputNames)
+    ? requiredInputNames.map((item) => typeof item === "string" ? { name: item, partitions: [] } : item).filter((item) => item?.name) : [];
+  const proofs = required.length > 0
+    ? required.map((item) => ({
+      proof: sourceCallableProof(bodies, name, requestedErrors, new Set(), contractText, name, [item.name], item.omissionSensitive ? [item.name] : [], [...new Set([...requestedPartitions, ...(item.partitions ?? [])])]),
+      partitions: [...new Set([...requestedPartitions, ...(item.partitions ?? [])])], inputName: item.name
+    }))
+    : [{ proof: sourceCallableProof(bodies, name, requestedErrors, new Set(), contractText, name, null, [], requestedPartitions), partitions: requestedPartitions, inputName: null }];
+  const callable = bodies.get(name);
+  return proofs.every(({ proof, partitions, inputName }) => proof.generic
+    && !(inputName && partitions.includes("missing") && callable?.defaultedParameters?.includes(inputName) && !proof.preservesExplicitUndefined)
+    && partitions.every((partition) => partitionCovered(partition, proof.partitions)));
 }
-
 function moduleBindingFreeCode(entry) {
   return normalizedText(sanitizeJavaScriptEvidence(entry?.text ?? ""))
     .replace(/\bimport\s+[\s\S]{1,800}?\s+from\s+__pi_(?:string|node_assert_module|code_generation_module|module_loader_module)_literal__\s*;?/g, " ")
@@ -847,8 +788,8 @@ export function acceptanceExecutableTestBinding(input = {}) {
     || typeof testEntry.path !== "string" || typeof testEntry.text !== "string") {
     return { linked: false, sourceNames: [], testNames: [] };
   }
-  const sourceCode = normalizedText(sanitizeJavaScriptEvidence(sourceEntry.text));
-  const testCode = normalizedText(sanitizeJavaScriptEvidence(testEntry.text));
+  const sourceCode = normalizedText(sanitizeJavaScriptEvidence(sourceEntry.text)), testCode = normalizedText(sanitizeJavaScriptEvidence(testEntry.text));
+  if ([sourceEntry.text, testEntry.text].some(hasReservedEvidenceIdentifier) || !lexicalEvidenceIsNonReflective(sourceCode) || !lexicalEvidenceIsNonReflective(testCode)) return { linked: false, sourceNames: [], testNames: [] };
   const bodies = callableBodies(sourceCode);
   const imports = staticModuleBindings(testEntry);
   const linkedSourceNames = [];
@@ -893,6 +834,7 @@ export function acceptanceInvalidInputEvidence(input = {}) {
   const requestedErrors = requestedErrorClasses(taskText);
   const ambiguousErrorIntent = hasAmbiguousErrorClassIntent(taskText);
   const requestedPartitions = requestedInvalidPartitions(taskText);
+  const taggedRequirements = malformedTaggedEventRequirements(taskText);
   // A constructor set alone cannot prove a mapping. Mixed-class evidence uses a narrow grammar;
   // ambiguous prose or indirect source/test proof abstains fail-closed.
   const requestedErrorMapping = requestedErrors.length > 1
@@ -903,19 +845,19 @@ export function acceptanceInvalidInputEvidence(input = {}) {
     .filter((entry) => entry && typeof entry.path === "string" && typeof entry.text === "string");
   const testEntries = (Array.isArray(input.testEntries) ? input.testEntries : [])
     .filter((entry) => entry && typeof entry.path === "string" && typeof entry.text === "string");
-  const bodyMaps = new Map(sourceEntries.map((entry) => [entryPath(entry.path), callableBodies(normalizedText(sanitizeJavaScriptEvidence(entry.text)))]));
-  if (sourceEntries.length === 0) bodyMaps.set("", callableBodies(sourceText));
+  const bodyMaps = new Map(sourceEntries.map((entry) => [entryPath(entry.path), casePreservingCallableBodies(sanitizeJavaScriptEvidence(entry.text), normalizedText(sanitizeJavaScriptEvidence(entry.text)))]));
+  if (sourceEntries.length === 0) bodyMaps.set("", casePreservingCallableBodies(sanitizeJavaScriptEvidence(input.sourceText), sourceText));
   const sourceLexicalOk = sourceEntries.length > 0 ? sourceEntries.every((entry) => !hasReservedEvidenceIdentifier(entry.text) && lexicalEvidenceIsNonReflective(normalizedText(sanitizeJavaScriptEvidence(entry.text)))) : !hasReservedEvidenceIdentifier(input.sourceText) && lexicalEvidenceIsNonReflective(sourceText);
   const testLexicalOk = testEntries.length > 0 ? testEntries.every((entry) => !hasReservedEvidenceIdentifier(entry.text) && lexicalEvidenceIsNonReflective(normalizedText(sanitizeJavaScriptEvidence(entry.text)))) : !hasReservedEvidenceIdentifier(input.testText) && lexicalEvidenceIsNonReflective(testText);
   const sourceConstructorOk = requestedErrors.length === 0 || (sourceEntries.length > 0
-    ? sourceEntries.every((entry) => intrinsicErrorBindingsUntampered(normalizedText(sanitizeJavaScriptEvidence(entry.text)), requestedErrors))
-    : intrinsicErrorBindingsUntampered(sourceText, requestedErrors));
+    ? sourceEntries.every((entry) => (intrinsicErrorBindingsUntampered(normalizedText(sanitizeJavaScriptEvidence(entry.text)), requestedErrors) || nativeErrorReferencesAreUnshadowed(entry.text, requestedErrors)))
+    : (intrinsicErrorBindingsUntampered(sourceText, requestedErrors) || nativeErrorReferencesAreUnshadowed(input.sourceText, requestedErrors)));
   const testConstructorOk = requestedErrors.length === 0 || (testEntries.length > 0
-    ? testEntries.every((entry) => intrinsicErrorBindingsUntampered(normalizedText(sanitizeJavaScriptEvidence(entry.text)), requestedErrors))
-    : intrinsicErrorBindingsUntampered(testText, requestedErrors));
+    ? testEntries.every((entry) => (intrinsicErrorBindingsUntampered(normalizedText(sanitizeJavaScriptEvidence(entry.text)), requestedErrors) || nativeErrorReferencesAreUnshadowed(entry.text, requestedErrors)))
+    : (intrinsicErrorBindingsUntampered(testText, requestedErrors) || nativeErrorReferencesAreUnshadowed(input.testText, requestedErrors)));
 
-  const strictTargets = namedTargets.filter((target) => provenanceTargets.has(target));
-  const structuralTargets = namedTargets.filter((target) => !provenanceTargets.has(target));
+  const { strictTargets, structuralTargets, unresolvedTargets } = routeNamedSourceTargets({
+    namedTargets, provenanceTargets, sourceEntries, exports: sourceEntries.flatMap(sourceExports), taskText });
   const bindings = strictTargets.length > 0 ? namedTargetBindings(sourceEntries, testEntries, strictTargets) : [];
   const inferred = namedTargets.length === 0 ? resolvedExportTestBindings(sourceEntries, testEntries) : [];
   const inferredAssertions = inferred.flatMap((binding) => {
@@ -932,16 +874,61 @@ export function acceptanceInvalidInputEvidence(input = {}) {
     testCodeEntries: testEntries.map((entry) => ({ path: entryPath(entry.path), code: normalizedText(sanitizeJavaScriptEvidence(entry.text)) })),
     fallbackTestCode: testText, bodyMaps
   });
+  const domains = integerDomainEvidence({ taskText, bindings, sourceEntries,
+    testCodeEntries: testEntries.map(entry => ({ path: entryPath(entry.path), raw: entry.text, code: normalizedText(sanitizeJavaScriptEvidence(entry.text)) })) });
+  if (domains) {
+    const sourceBound = unresolvedTargets.length === 0 && structuralTargets.length === 0 && sourceLexicalOk && sourceConstructorOk && !ambiguousErrorIntent;
+    const testsBound = unresolvedTargets.length === 0 && testLexicalOk && testConstructorOk && boundTestEvidence.targetOk && boundTestEvidence.modeOk && !ambiguousErrorIntent;
+    const evidence = { sourceOk: sourceBound && domains.sourceOk, testOk: testsBound && domains.testOk };
+    return input.includeDiagnostics === true ? { ...evidence, integerDomainProof: { ...domains.integerDomainProof,
+      rejectionEstablished: sourceBound && domains.integerDomainProof.rejectionEstablished,
+      wholeCriterionEstablished: evidence.sourceOk && evidence.testOk },
+      sourceReasons: domains.integerDomainProof.unprovedClauses.length > 0 ? ["additional-contract-clauses-unproved"] : [] } : evidence;
+  }
+  const temporal = temporalContractEvidence({ taskText, bindings, bodyMaps,
+    testRequirements: boundTestEvidence.bindingArgumentRequirements ?? [] });
+  const dependencyGraph=dependencyCycleEvidence({taskText,bindings:namedTargets.length?bindings:inferred,sourceEntries,testEntries});if(dependencyGraph)return {sourceOk:dependencyGraph.sourceOk && unresolvedTargets.length===0 && structuralTargets.length===0 && sourceLexicalOk && sourceConstructorOk && !ambiguousErrorIntent,testOk:dependencyGraph.testOk && unresolvedTargets.length===0 && testLexicalOk && testConstructorOk && !ambiguousErrorIntent,...(input.includeDiagnostics?{dependencyGraph,dependencyFlags:{testLexicalOk,testConstructorOk,sourceLexicalOk,sourceConstructorOk,unresolvedTargets,structuralTargets,ambiguousErrorIntent}}: {})};  const orderedRecords=orderedRecordRejectionEvidence({taskText,contextText:input.contextText,bindings:namedTargets.length?bindings:inferred,sourceEntries,testEntries}); if(orderedRecords)return {sourceOk:orderedRecords.sourceOk && unresolvedTargets.length===0 && structuralTargets.length===0 && sourceLexicalOk && sourceConstructorOk && !ambiguousErrorIntent,testOk:orderedRecords.testOk && unresolvedTargets.length===0 && testLexicalOk && testConstructorOk && !ambiguousErrorIntent,...(input.includeDiagnostics?{orderedRecords}: {})};
+  const finiteRecords = finiteIntervalRecordEvidence({ taskText, contextText: input.contextText, bindings: namedTargets.length ? bindings : inferred, sourceEntries,
+    testEntries: testEntries.map(entry => ({ ...entry, code: normalizedText(sanitizeJavaScriptEvidence(entry.text)) })) });
+  const declaredIntegerContract = rejectedIntegerParameter(taskText, input.contextText);
+  const integerContract = structuralTargets.length === 0 || declaredIntegerContract?.parameters ? declaredIntegerContract : null;
+  const integerCandidates = integerContract?.parameters && namedTargets.length === 0 ? inferred : bindings;
+  const integerBindings = new Map(integerCandidates.map(binding => [binding, integerParameterBindingEvidence({
+    contract: integerContract, binding: binding.testNames ? binding : { ...binding, target: binding.sourceName, testNames: [binding.testName] }, parameters: bodyMaps.get(binding.sourcePath)?.get(binding.sourceName)?.parameters ?? [],
+    assertions: namedTargets.length > 0 ? boundTestEvidence.assertions : inferredAssertions.filter(item => item.binding === binding).map(item => item.assertion), sourceEntries, testEntries })]));
   const assertions = namedTargets.length > 0 ? boundTestEvidence.assertions : inferredAssertions.map((item) => item.assertion);
   const mappingTestOk = namedTargets.length > 0 ? boundTestEvidence.mappingOk : requestedErrors.length <= 1;
-  const targetOk = namedTargets.length > 0 ? boundTestEvidence.targetOk : assertions.length > 0;
-  const sourceOk = sourceLexicalOk && sourceConstructorOk && (namedTargets.length > 0
+  const targetOk = unresolvedTargets.length === 0 && (namedTargets.length > 0 ? boundTestEvidence.targetOk : assertions.length > 0);
+  const requiredInputsForBinding = (binding) => {
+    if (integerBindings.get(binding)) return integerBindings.get(binding).inputs;
+    const requirement = (boundTestEvidence.bindingArgumentRequirements ?? [])
+      .find((item) => item.sourcePath === binding.sourcePath && item.sourceName === binding.sourceName);
+    const callable = (bodyMaps.get(binding.sourcePath) ?? new Map()).get(binding.sourceName);
+    const required = temporalInputRequirements({ binding, observed: requirement, parameters: callable?.parameters,
+      requestedPartitions, temporalBindings: temporal.bindings });
+    const temporalInputs = temporal.bindings
+      .find((item) => item.sourcePath === binding.sourcePath && item.sourceName === binding.sourceName)?.inputs ?? [];
+    return required?.map((item) => ({
+      ...item,
+      omissionSensitive: temporalInputs.some((temporalInput) => temporalInput.name === item.name
+        && temporalInput.partitions.includes("missing"))
+    })) ?? required;
+  };
+  const inferredTerminal = (binding) => {
+    const callable = bodyMaps.get(binding.sourcePath)?.get(binding.sourceName);
+    return sourceEntries.flatMap(sourceExports).length === 1 && inferred.every(item => item.sourcePath === binding.sourcePath && item.sourceName === binding.sourceName)
+      && requestedPartitions.length === 0 && callable && statefulTerminalRejectionEvidence(callable.body, callable.parameters, requestedErrors, taskText, binding.sourceName, callable.sourceCode, true);
+  };
+  const sourceOk = unresolvedTargets.length === 0 && sourceLexicalOk && sourceConstructorOk && (namedTargets.length > 0
     ? bindings.length === strictTargets.length
-      && bindings.every((binding) => Boolean(binding.sourcePath) && Boolean(binding.sourceName) && sourceCallableProves(bodyMaps.get(binding.sourcePath) ?? new Map(), binding.sourceName, requestedErrors, requestedPartitions, taskText))
+      && bindings.every((binding) => Boolean(binding.sourcePath) && Boolean(binding.sourceName) && (sourceCallableProves(
+        bodyMaps.get(binding.sourcePath) ?? new Map(), binding.sourceName, requestedErrors, requestedPartitions, taskText,
+        requiredInputsForBinding(binding)
+      ) || integerBindings.get(binding)?.recordSourceOk === true || finiteRecords.provesSource?.(binding) === true))
       && structuralTargets.every((target) => [...bodyMaps.values()].filter((bodies) => bodies.has(target)).length === 1
         && [...bodyMaps.values()].some((bodies) => sourceCallableProves(bodies, target, requestedErrors, requestedPartitions, taskText)))
     : inferredAssertions.length > 0 && inferredAssertions.every(({ binding }) => (
-        sourceCallableProves(bodyMaps.get(binding.sourcePath) ?? new Map(), binding.sourceName, requestedErrors, requestedPartitions, taskText)
+        sourceCallableProves(bodyMaps.get(binding.sourcePath) ?? new Map(), binding.sourceName, requestedErrors, requestedPartitions, taskText, integerContract?.parameters ? requiredInputsForBinding(binding) : null) || inferredTerminal(binding) || integerBindings.get(binding)?.recordSourceOk === true || finiteRecords.provesSource?.(binding) === true
       ))) && (requestedErrors.length <= 1 || Boolean(requestedErrorMapping && namedTargets.length > 0
         && bindings.every((binding) => sourceCallableProvesErrorMapping(
           bodyMaps.get(binding.sourcePath) ?? new Map(), binding.sourceName, requestedErrorMapping
@@ -954,8 +941,21 @@ export function acceptanceInvalidInputEvidence(input = {}) {
       ));
   const partitions = new Set(assertions.flatMap((assertion) => [...assertion.partitions]));
   const partitionOk = requestedPartitions.every((partition) => partitionCovered(partition, partitions));
-  return { sourceOk: sourceOk && !ambiguousErrorIntent,
-    testOk: testLexicalOk && testConstructorOk && targetOk && partitionOk && mappingTestOk && assertionModeOk && !ambiguousErrorIntent };
+  const sourceByPath = new Map(sourceEntries.map((entry) => [entryPath(entry.path), entry.text])), testByPath = new Map(testEntries.map((entry) => [entryPath(entry.path), entry.text]));
+  const sourceGroups = namedTargets.length > 0
+    ? [...bindings.map((item) => ({ raw: sourceByPath.get(item.sourcePath), name: item.sourceName })), ...structuralTargets.map((name) => {
+        const matches = [...bodyMaps.entries()].filter(([, bodies]) => bodies.has(name));
+        return { raw: matches.length === 1 ? sourceByPath.get(matches[0][0]) : undefined, name: matches.length === 1 ? name : undefined };
+      })] : inferred.map((item) => ({ raw: sourceByPath.get(item.sourcePath), name: item.sourceName }));
+  const testGroups = namedTargets.length > 0
+    ? [...bindings.map((item) => (item.testBindings ?? []).map((binding) => ({ raw: testByPath.get(binding.testPath), names: new Set([binding.testName]) }))),
+        ...structuralTargets.map((target) => testEntries.map((entry) => ({ raw: entry.text, names: new Set([`*.${target}`]) })))]
+    : inferred.map((item) => [{ raw: testByPath.get(item.testPath), names: new Set([item.testName]) }]);
+  const tagged = malformedTaggedEventEvidence({ requirements: taggedRequirements, requestedErrors, sourceGroups, testGroups,
+    sourceCorpus: sourceEntries.map((entry) => entry.text).join("\n"), testCorpus: testEntries.map((entry) => entry.text).join("\n") });
+  const integerSourceOk = !integerContract || (integerCandidates.length > 0 && [...integerBindings.values()].every(item => item.sourceOk));
+  const integerTestOk = !integerContract || (integerCandidates.length > 0 && [...integerBindings.values()].every(item => item.testOk));
+  return withInvalidSentinelDiagnostics({ sourceOk: sourceOk && finiteRecords.sourceOk && integerSourceOk && tagged.sourceOk && !ambiguousErrorIntent, testOk: finiteRecords.testOk && testLexicalOk && testConstructorOk && targetOk && partitionOk && mappingTestOk && assertionModeOk && temporal.testOk && integerTestOk && tagged.testOk && !ambiguousErrorIntent }, { enabled: input.includeDiagnostics === true, bodyMaps, namedTargets, requestedErrors, requestedPartitions });
 }
 
 export function acceptanceContractProofGuidance(raw) {
@@ -963,16 +963,16 @@ export function acceptanceContractProofGuidance(raw) {
   const guidance = [...acceptanceBoundaryProofGuidance(raw)];
   if (onlyUndefinedContract(raw)) guidance.push("Prove undefined falls through while null, false, 0, and empty string are each preserved at the highest-precedence position.");
   const requestedSpecificErrors = hasAmbiguousErrorClassIntent(raw) ? [] : requestedErrorClasses(raw).map((errorClass) => ERROR_CONSTRUCTOR_DISPLAY_NAMES[errorClass]).filter(Boolean);
-  if (requestedSpecificErrors.length === 1) guidance.push(`Assert ${requestedSpecificErrors[0]} for every rejected partition named by the request; a different error class is not equivalent.`);
+  if (requestedSpecificErrors.length === 1) guidance.push(rejectionClassProofGuidance(raw, requestedSpecificErrors[0]));
   if (requestedSpecificErrors.length > 1) guidance.push(`Preserve the request's partition-to-error mapping: assert each rejected partition with its explicitly named class (${requestedSpecificErrors.join(", ")}); do not apply one class to every partition.`);
-  const integerTargets = integerConstraintTargets(raw);
-  if (integerTargets.length > 0) guidance.push(`Reject fractional values for every integer-constrained argument (${integerTargets.join(", ")}).`);
+  const integerTargets = integerConstraintTargets(raw); if (integerTargets.length > 0) guidance.push(`Reject fractional values for every integer-constrained argument (${integerTargets.join(", ")}).`);
   const nullRejectingTargets = nullRejectingDefaultTargets(raw);
   if (nullRejectingTargets.length > 0) guidance.push(`Prove omitted or undefined defaults separately from supplied null for: ${nullRejectingTargets.join(", ")}.`);
   if (/\bpositive integer\b/.test(value)) guidance.push("Exercise zero and a negative value for every positive-integer constraint.");
   if (/\bnon-negative\b/.test(value)) guidance.push("Exercise zero as valid and a negative value as invalid for every non-negative constraint.");
   if (/\binclusive\b|\bthrough\b|\bfrom\b[^.\n]{0,80}\bto\b/.test(value)) guidance.push("Exercise both inclusive endpoints and the nearest value outside each endpoint.");
   if (/\bround(?:ing)?\b|\bceil(?:ing)?\b|\bclamp\b/.test(value)) guidance.push("Exercise zero, exact, partial/rounding, below-minimum, and above-maximum behavior where applicable.");
+  guidance.push(...isoTimestampProofGuidance(raw));
   return uniqueStrings(guidance).slice(0, 8);
 }