@redsift/products 12.5.12-alpha.3 → 12.5.12-alpha.4

package/_internal/SignalCardSpfDomain.js

@@ -539,7 +539,31 @@ var EXTRACTOR_STRINGS = {
     "investigate:card.dmarc.full-rejection-subdomain-weak_md": "**100%** of unauthorized emails with the [](FROM#:glossary) `{domain}` will be **rejected**, but subdomains use a weaker policy (sp={sp}), leaving them vulnerable to spoofing.",
     "investigate:card.dmarc.misplaced-bad-policy_md": "**The [FULL](DMARC_POLICY#:glossary) is misplaced and has a syntax error:**",
     "investigate:card.dmarc.misplaced-policy_md": "**The [FULL](DMARC_POLICY#:glossary) is misplaced.**",
-    "investigate:card.dmarc.multiple-policies_md": "**More than one [FULL](DMARC_POLICY#:glossary) is published on `{policyDomain}`.** Receivers stop policy discovery and apply no DMARC policy at all, so the domain is unprotected. Publish exactly one DMARC record.",
+    // WEB-1243: standards-neutral. The previous wording said receivers "stop policy
+    // discovery and apply no DMARC policy at all", which is RFC 7489 §6.6.3 step 5 only.
+    // RFC 9989 §4.10 receivers discard the duplicates and CONTINUE the tree walk, so an
+    // ancestor policy may still apply — and DNS-DMARC-0044, the live signal on current
+    // production, is emitted by exactly those receivers. Stating the RFC 7489 behaviour
+    // as universal was therefore false for the code that now triggers this message.
+    // Rewritten to assert only what is true on both: the outcome is receiver-dependent
+    // and therefore unreliable, and the fix is the same either way.
+    "investigate:card.dmarc.multiple-policies_md": "**More than one [FULL](DMARC_POLICY#:glossary) is published on `{policyDomain}`.** Handling depends on the receiver: some stop policy discovery and apply no DMARC policy at all, others discard the duplicate records and continue. Your policy cannot be relied on for any recipient while more than one record is published. Publish exactly one DMARC record.",
+    // WEB-1243: the UNCONFIRMED counterpart. `indeterminate` means the check could not
+    // finish, NOT that duplicates were found. It resolves to a danger status on purpose —
+    // an unproven absence must not read as a proven one on a security signal — but the copy
+    // must not then assert the conflict as fact. `multiple-policies_md` says duplicates ARE
+    // published and to publish exactly one record, which on this path would tell a user
+    // with a healthy single record to change it.
+    //
+    // DELIBERATELY CAUSE-NEUTRAL. `indeterminate` has more than one cause: the scan budget
+    // running out, AND a candidate entry the check could not read (a rendered display group
+    // reaching a semantic position). An earlier draft said "the domain published more
+    // records than this check inspects", which is a FALSE statement of fact on the second
+    // cause — a one-name payload got told it had published too many records. Naming any
+    // single cause here is wrong unless the reason is carried alongside the verdict, so the
+    // copy states only what is true of every path: not everything was inspected, and the
+    // reader should go and look.
+    "investigate:card.dmarc.multiple-policies-unconfirmed_md": "**We could not fully check how many [FULL](DMARC_POLICY#:glossary) records are published on `{policyDomain}`.** This check did not inspect every record, so we cannot confirm whether more than one is live. If more than one is published, your policy cannot be relied on for any recipient. Review the DNS zone for `{policyDomain}` and confirm it publishes exactly one DMARC record.",
     "investigate:card.dmarc.no-policy_md": "**No [FULL](DMARC_POLICY#:glossary) published on domain**\n\n**`{policyDomain}`**",
     "investigate:card.dmarc.no-txt-published-policy-on-domain_md": "No [](TXT_RECORDS#:glossary) published on `{policyDomain}`",
     "investigate:card.dmarc.permerror-no-rua_md": "No valid reporting URI ([](RUA#:glossary)) is present, so receivers will skip DMARC processing entirely.",
@@ -1026,7 +1050,8 @@ var EXTRACTOR_STRINGS = {
     "investigate:card.dmarc.full-rejection-subdomain-weak_md": "**100%** des courriels non autoris\xE9s avec le [](FROM#:glossary) `{domain}` seront **rejet\xE9s**, mais les sous-domaines utilisent une politique plus faible (sp={sp}), les laissant vuln\xE9rables \xE0 l'usurpation.",
     "investigate:card.dmarc.misplaced-bad-policy_md": "**Le [FULL](DMARC_POLICY#:glossary) est mal plac\xE9 et a une erreur de syntaxe:**",
     "investigate:card.dmarc.misplaced-policy_md": "**Le [FULL](DMARC_POLICY#:glossary) est mal plac\xE9.",
-    "investigate:card.dmarc.multiple-policies_md": "**Plusieurs [FULL](DMARC_POLICY#:glossary) sont publi\xE9es sur `{policyDomain}`.** Les destinataires interrompent la d\xE9couverte de la politique et n'appliquent aucune politique DMARC, le domaine n'est donc pas prot\xE9g\xE9. Publiez un seul enregistrement DMARC.",
+    "investigate:card.dmarc.multiple-policies_md": "**Plusieurs [FULL](DMARC_POLICY#:glossary) sont publi\xE9es sur `{policyDomain}`.** Le traitement d\xE9pend du destinataire : certains interrompent la d\xE9couverte de la politique et n'appliquent aucune politique DMARC, d'autres ignorent les enregistrements en double et continuent. Votre politique ne peut \xEAtre consid\xE9r\xE9e comme fiable pour aucun destinataire tant que plusieurs enregistrements sont publi\xE9s. Publiez un seul enregistrement DMARC.",
+    "investigate:card.dmarc.multiple-policies-unconfirmed_md": "**Nous n'avons pas pu v\xE9rifier enti\xE8rement combien d'enregistrements [FULL](DMARC_POLICY#:glossary) sont publi\xE9s sur `{policyDomain}`.** Cette v\xE9rification n'a pas inspect\xE9 tous les enregistrements, nous ne pouvons donc pas confirmer si plusieurs sont actifs. Si plusieurs sont publi\xE9s, votre politique ne peut \xEAtre consid\xE9r\xE9e comme fiable pour aucun destinataire. Examinez la zone DNS de `{policyDomain}` et confirmez qu'elle publie un seul enregistrement DMARC.",
     "investigate:card.dmarc.no-policy_md": "**Aucune [FULL](DMARC_POLICY#:glossary) publi\xE9e sur le domaine**\n\n**`{policyDomain}`**",
     "investigate:card.dmarc.no-txt-published-policy-on-domain_md": "Aucun [](TXT_RECORD#:glossary) publi\xE9 sur `{policyDomain}`",
     "investigate:card.dmarc.permerror-no-rua_md": "Aucun URI de rapport valide ([](RUA#:glossary)) n'est pr\xE9sent, les destinataires ignoreront enti\xE8rement le traitement DMARC.",
@@ -1316,6 +1341,7 @@ var enUS = {
 	"investigate.card.dmarc.policy-remaining-emails-pct-reject_md": "The remaining **{remainingPercent}%** of unauthorized emails will be subject to the **quarantine** policy.",
 	"investigate.card.dmarc.policy-remaining-emails-pct-quarantine_md": "The remaining **{remainingPercent}%** of unauthorized emails will be **delivered normally**.",
 	"investigate.card.dmarc.no-policy_md": "**No [FULL](DMARC_POLICY#:glossary) published on domain**\n\n**`{policyDomain}`**",
+	"investigate.card.dmarc.multiple-policies_md": "**More than one [FULL](DMARC_POLICY#:glossary) is published on `{policyDomain}`.** Handling depends on the receiver: some stop policy discovery and apply no DMARC policy at all, others discard the duplicate records and continue. Your policy cannot be relied on for any recipient while more than one record is published. Publish exactly one DMARC record.",
 	"investigate.card.dmarc.dmarc-passed_md": "[](DMARC#:glossary) **passed**",
 	"investigate.card.dmarc.dmarc-passed-no-rua_md": "[](DMARC#:glossary) is BIMI compliant **BUT** it does not have an **aggregate report address** (rua) entry.",
 	"investigate.card.dmarc.dmarc-no-rua_md": "[](DMARC#:glossary) does not have an **aggregate report address** (rua) entry.",
@@ -1935,7 +1961,14 @@ var enUS = {
 	"investigate.card.dmarc.domain-aligned": "The domain is aligned with the From Domain. It can contribute to passing DMARC.",
 	"investigate.card.dmarc.domain-aligned-not-verified": "The domain is aligned with the From Domain, but its signature did not verify, so it cannot contribute to passing DMARC.",
 	"investigate.card.dmarc.spf-domain-aligned-not-verified": "The domain is aligned with the From Domain, but SPF did not pass, so it cannot contribute to passing DMARC.",
-	"investigate.card.dmarc.domain-not-aligned": "The domain is not aligned with the From Domain. It cannot contribute to passing DMARC."
+	"investigate.card.dmarc.domain-not-aligned": "The domain is not aligned with the From Domain. It cannot contribute to passing DMARC.",
+	"investigate.card.dmarc.multiple-policies-unconfirmed_md": "**We could not fully check how many [FULL](DMARC_POLICY#:glossary) records are published on `{policyDomain}`.** This check did not inspect every record, so we cannot confirm whether more than one is live. If more than one is published, your policy cannot be relied on for any recipient. Review the DNS zone for `{policyDomain}` and confirm it publishes exactly one DMARC record.",
+	"investigate.card.extracted.truncated-records": "[… {count} more records not shown]",
+	"investigate.card.extracted.truncated-records_one": "[… 1 more record not shown]",
+	"investigate.card.extracted.truncated-records-atleast": "[… at least {count} more records not shown]",
+	"investigate.card.extracted.truncated-records-uninspected": "[… further records not inspected]",
+	"investigate.card.extracted.truncated-record-length": "[… long records shortened for display]",
+	"investigate.card.extracted.truncated-records-atleast_one": "[… at least 1 more record not shown]"
 };
 
 var frFR = {
@@ -2034,6 +2067,7 @@ var frFR = {
 	"investigate.card.dmarc.policy-remaining-emails-pct-reject_md": "Les **{remainingPercent}%** restants de courriels non autorisés seront soumis à la politique de **mise en quarantaine**.",
 	"investigate.card.dmarc.policy-remaining-emails-pct-quarantine_md": "Les **{remainingPercent}%** restants de courriels non autorisés seront **livrés normalement**.",
 	"investigate.card.dmarc.no-policy_md": "**Aucune [FULL](DMARC_POLICY#:glossary) publiée sur le domaine**\n\n**`{policyDomain}`**",
+	"investigate.card.dmarc.multiple-policies_md": "**Plusieurs [FULL](DMARC_POLICY#:glossary) sont publiées sur `{policyDomain}`.** Le traitement dépend du destinataire : certains interrompent la découverte de la politique et n'appliquent aucune politique DMARC, d'autres ignorent les enregistrements en double et continuent. Votre politique ne peut être considérée comme fiable pour aucun destinataire tant que plusieurs enregistrements sont publiés. Publiez un seul enregistrement DMARC.",
 	"investigate.card.dmarc.dmarc-passed_md": "[](DMARC#:glossary) **réussi**",
 	"investigate.card.dmarc.dmarc-passed-no-rua_md": "[](DMARC#:glossary) est conforme à BIMI **MAIS** n'a pas d'**adresse de rapport agrégé** (rua).",
 	"investigate.card.dmarc.dmarc-no-rua_md": "[](DMARC#:glossary) n'a pas d'**adresse de rapport agrégé** (rua).",
@@ -2655,7 +2689,14 @@ var frFR = {
 	"investigate.card.dmarc.domain-aligned": "Le domaine est aligné avec le domaine expéditeur. Il peut contribuer à la réussite de DMARC.",
 	"investigate.card.dmarc.domain-aligned-not-verified": "Le domaine est aligné avec le domaine expéditeur, mais sa signature n'a pas été vérifiée, il ne peut donc pas contribuer à la réussite de DMARC.",
 	"investigate.card.dmarc.spf-domain-aligned-not-verified": "Le domaine est aligné avec le domaine expéditeur, mais SPF n'a pas réussi, il ne peut donc pas contribuer à la réussite de DMARC.",
-	"investigate.card.dmarc.domain-not-aligned": "Le domaine n'est pas aligné avec le domaine expéditeur. Il ne peut pas contribuer à la réussite de DMARC."
+	"investigate.card.dmarc.domain-not-aligned": "Le domaine n'est pas aligné avec le domaine expéditeur. Il ne peut pas contribuer à la réussite de DMARC.",
+	"investigate.card.dmarc.multiple-policies-unconfirmed_md": "**Nous n'avons pas pu vérifier entièrement combien d'enregistrements [FULL](DMARC_POLICY#:glossary) sont publiés sur `{policyDomain}`.** Cette vérification n'a pas inspecté tous les enregistrements, nous ne pouvons donc pas confirmer si plusieurs sont actifs. Si plusieurs sont publiés, votre politique ne peut être considérée comme fiable pour aucun destinataire. Examinez la zone DNS de `{policyDomain}` et confirmez qu'elle publie un seul enregistrement DMARC.",
+	"investigate.card.extracted.truncated-records": "[… {count} enregistrements supplémentaires non affichés]",
+	"investigate.card.extracted.truncated-records_one": "[… 1 enregistrement supplémentaire non affiché]",
+	"investigate.card.extracted.truncated-records-atleast": "[… au moins {count} enregistrements supplémentaires non affichés]",
+	"investigate.card.extracted.truncated-records-uninspected": "[… enregistrements supplémentaires non examinés]",
+	"investigate.card.extracted.truncated-record-length": "[… enregistrements longs raccourcis pour l’affichage]",
+	"investigate.card.extracted.truncated-records-atleast_one": "[… au moins 1 enregistrement supplémentaire non affiché]"
 };
 
 /**
@@ -4828,8 +4869,49 @@ const CodeBlock = styled.div`
     display: none !important;
   }
 `;
+
+/**
+ * One logical line inside a `CodeBlock` — typically a single published DNS record.
+ *
+ * DS-115: a domain can publish more than one competing `_dmarc` TXT record, and the card
+ * must show them as distinct records. `CodeBlock` forces `p { display: inline }`, which
+ * flowed them into one unbroken line, so multi-line values use this block-level wrapper
+ * instead of a `<p>`.
+ */
+const CodeBlockLine = styled.div`
+  display: block;
+  white-space: pre-wrap;
+  word-break: break-all;
+
+  & + & {
+    margin-top: 4px;
+  }
+`;
+
+/**
+ * Renderer commentary about a truncated literal value — NOT zone content.
+ *
+ * DS-115. Deliberately its own component rather than a reused `ExtractionCaption`: that one
+ * is `position: absolute`, anchored to an `ExtractionBox`, so on the paths that have no
+ * positioned ancestor it would escape its container, and inside a box it would land on the
+ * same coordinates as the ordinary caption. This stays in normal flow directly beneath the
+ * code block.
+ *
+ * Visually distinct from `CodeBlockLine` on purpose — italic, not monospace — because a zone
+ * can publish a record whose text imitates this notice, and the two must not be confusable.
+ */
+const LiteralTruncationNotice = styled.div`
+  display: block;
+  margin-top: 6px;
+  font-style: italic;
+  font-size: 12px;
+  opacity: 0.75;
+  word-break: break-word;
+`;
 ExtractionBox.displayName = 'ExtractionBox';
 ExtractionCaption.displayName = 'ExtractionCaption';
+CodeBlockLine.displayName = 'CodeBlockLine';
+LiteralTruncationNotice.displayName = 'LiteralTruncationNotice';
 InfoItemsHighlight.displayName = 'InfoItemsHighlight';
 
 // All theming uses CSS variables with Design System fallbacks (Poppins).
@@ -6642,19 +6724,244 @@ function getIcon(_ref) {
     size: "small"
   }) : null;
 }
-const renderExtractedValue = (value, keyPrefix) => {
+
+/**
+ * Lines a literal (code-block) render may emit, shared across ONE CATEGORY.
+ *
+ * Scope is per category, not per card: `ExtractedCategoryContent` creates one budget and
+ * threads it through every item and leaf it renders, so a card with N literal categories can
+ * emit up to N x this figure. That is deliberate — a category is the unit a reader looks at,
+ * and letting one category's pathological payload blank out a sibling section would trade a
+ * bounded render for a misleading one.
+ *
+ * Two earlier attempts were not bounds at all. A per-leaf cap failed because
+ * `renderExtractedValue` recurses into arrays (5,000 one-line entries → 5,004 nodes). A
+ * per-value cap failed because upstream emits one item PER CANDIDATE GROUP, so 20 groups each
+ * got a fresh 50 (→ 1,000 lines, 20 notices).
+ *
+ * Generous for real data: a real `_dmarc` name publishes one record and the pathological
+ * production case is two.
+ */
+const MAX_LITERAL_LINES = 50;
+
+/**
+ * Characters rendered per literal line.
+ *
+ * Count alone does not bound size — 50 lines of 200KB each rendered 10,001,001 characters
+ * (measured). 4096 rather than upstream's 512 context bound: this is the UI, and legitimate
+ * evidence exceeds 512 — a DNS TXT RR concatenates multiple 255-octet strings, and a
+ * 4096-bit DKIM `p=` value alone is ~740 characters. 512 would have silently truncated real
+ * keys, which on a card whose job is showing published records is a correctness bug, not a
+ * safety measure.
+ */
+const MAX_LITERAL_LINE_CHARS = 4096;
+
+/**
+ * Total literal characters per CATEGORY, independent of the per-line cap.
+ *
+ * The per-line cap alone still allows `MAX_LITERAL_LINES × MAX_LITERAL_LINE_CHARS`. This is
+ * the ceiling that actually bounds payload size. Same per-category scope as
+ * `MAX_LITERAL_LINES` — see that note.
+ */
+const MAX_LITERAL_TOTAL_CHARS = 64000;
+
+/**
+ * Array entries VISITED per category, whatever they turn out to contain.
+ *
+ * Distinct from the line budget, which bounds output: entries that contribute nothing —
+ * empty strings, whitespace, nulls — do not consume output quota, so a scan that stopped
+ * only on the output budget could still walk a million entries. Nothing past this is read.
+ */
+const MAX_LITERAL_ENTRIES_SCANNED = 2000;
+
+/**
+ * Shared, mutable literal render budget for one CATEGORY.
+ *
+ * `hiddenLines` is a LOWER BOUND, not an exact count: producing an exact figure would mean
+ * scanning every withheld character of an attacker-controlled value, which is unbounded work
+ * for a number nobody acts on. Copy says "at least N" / "not inspected" accordingly.
+ */
+
+const createLiteralBudget = () => ({
+  lines: MAX_LITERAL_LINES,
+  chars: MAX_LITERAL_TOTAL_CHARS,
+  entries: MAX_LITERAL_ENTRIES_SCANNED,
+  hiddenLines: 0,
+  hiddenUncounted: false,
+  shortenedLines: false
+});
+const budgetExhausted = b => b.lines <= 0 || b.chars <= 0;
+
+/**
+ * Truncate without splitting a surrogate pair.
+ *
+ * A bare `slice` cuts UTF-16 code units, so a boundary landing between a high and low
+ * surrogate emits a replacement glyph — a rendering artifact in what is supposed to be a
+ * verbatim record.
+ */
+const sliceWholeCodePoints = (value, max) => {
+  if (value.length <= max) {
+    return value;
+  }
+  const code = value.charCodeAt(max - 1);
+  // High surrogate at the boundary: its pair would be cut, so drop it too.
+  const end = code >= 0xd800 && code <= 0xdbff ? max - 1 : max;
+  return value.slice(0, end);
+};
+
+/**
+ * Render an extracted value.
+ *
+ * `literal` is set for code-block values (DNS TXT records and similar). Those come from
+ * the inspected domain's own zone, NOT from our translations, so they are attacker-
+ * controlled and must never go through `parseGlossaryMarkdown` — its documented trust
+ * model assumes source-controlled input, and it turns `[text](https://...)` into a real
+ * anchor. See the adversarial tests in `SignalCardExtractedItems.test.tsx`.
+ */
+const renderExtractedValue = function (value, keyPrefix) {
+  let literal = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  let budget = arguments.length > 3 ? arguments[3] : undefined;
   const nodes = [];
+  // A local budget when none is shared, so non-card callers still get a bound.
+  const b = budget !== null && budget !== void 0 ? budget : createLiteralBudget();
   const process = (input, prefix) => {
     if (input === null || input === undefined) {
       return;
     }
     if (Array.isArray(input)) {
-      input.forEach((entry, idx) => process(entry, `${prefix}-${idx}`));
+      for (const entry of input) {
+        // Stop traversing once nothing more can be emitted: continuing would walk the whole
+        // attacker-controlled array to render nothing.
+        if (literal && (budgetExhausted(b) || b.entries <= 0)) {
+          b.hiddenUncounted = true;
+          return;
+        }
+        if (literal) {
+          b.entries -= 1;
+        }
+        process(entry, `${prefix}-${nodes.length}`);
+      }
       return;
     }
     if (typeof input === 'string') {
-      const trimmed = input.trim();
-      if (!trimmed) {
+      const trimmed = literal ? undefined : input.trim();
+      if (!literal && !trimmed) {
+        return;
+      }
+
+      // DS-115: in literal (code-block) mode a single string leaf may itself carry multiple
+      // records separated by newlines — and so may a string nested inside an array, e.g.
+      // `['record A\nrecord B']`. Split every string leaf, not just a top-level one, so each
+      // record gets its own <p> (and so its own CodeBlockLine) rather than flowing together.
+      if (literal) {
+        // Every line becomes a React element and a styled `CodeBlockLine`, and the values are
+        // attacker-controlled: DNS TXT records read from the domain under inspection.
+        // Upstream deliberately does NOT bound the card path (only the context/LLM path is
+        // capped) because a display cap that dropped a whole name could make the
+        // multiple-records predicate deny a real conflict. That is right upstream, and it
+        // makes the RENDER side the place to bound node count and byte size.
+        //
+        // Scanned with an index-bounded loop rather than `split().map().filter().slice()`:
+        // the chained form materializes every line of an adversarial value before discarding
+        // almost all of it, so the work is unbounded even though the output is not. The
+        // string is never `trim()`ed as a whole either — that copies the entire input.
+        let cursor = 0;
+        while (cursor < input.length && !budgetExhausted(b)) {
+          // Bound the scan for one line's end by what could still be rendered, so a single
+          // 10-million-character line is never fully walked or normalized.
+          const scanLimit = Math.min(input.length, cursor + MAX_LITERAL_LINE_CHARS + 1);
+          let next = cursor;
+          while (next < scanLimit && input[next] !== '\n' && input[next] !== '\r') {
+            next += 1;
+          }
+          const overlong = next === scanLimit && next < input.length && input[next] !== '\n' && input[next] !== '\r';
+          const raw = input.slice(cursor, next);
+          const line = raw.replace(/\s+/g, ' ').trim();
+          if (overlong) {
+            // Skip this line’s untruncated remainder WITHOUT materializing it — and BOUND the skip.
+            // Walking to the next newline is still O(input): a 40-million-character line with no
+            // newline took ~164ms against ~97ms for 20M, so the work was linear in attacker input
+            // even though the OUTPUT was bounded. Give up after a bounded probe and report the
+            // rest as uninspected rather than scanning it.
+            const skipLimit = cursor + MAX_LITERAL_LINE_CHARS;
+            while (cursor < input.length && cursor < skipLimit && input[cursor] !== '\n' && input[cursor] !== '\r') {
+              cursor += 1;
+            }
+            if (cursor < input.length && input[cursor] !== '\n' && input[cursor] !== '\r') {
+              // The skip budget ran out before this line ended. Record that the withheld
+              // figure is a floor, then stop consuming budget so the reporting block below
+              // still runs from this cursor — an early `break` here escaped the loop and
+              // skipped reporting entirely, leaving NO notice at all (caught by test).
+              b.hiddenUncounted = true;
+              b.lines = 0;
+            }
+          } else {
+            cursor = next;
+          }
+
+          // Advance past the whole run of newline characters, matching the previous
+          // `/[\r\n]+/` split so a CRLF pair does not emit a blank line between records.
+          while (cursor < input.length && (input[cursor] === '\n' || input[cursor] === '\r')) {
+            cursor += 1;
+          }
+          if (!line) {
+            continue;
+          }
+          const allowed = Math.min(MAX_LITERAL_LINE_CHARS, b.chars);
+          const shown = sliceWholeCodePoints(line, allowed);
+          if (shown.length < line.length || overlong) {
+            b.shortenedLines = true;
+          }
+          nodes.push( /*#__PURE__*/React__default.createElement("p", {
+            key: `${prefix}-text-${nodes.length}`
+          }, shown));
+          b.lines -= 1;
+          b.chars -= shown.length;
+        }
+
+        // Report — never silently drop. This card exists to tell someone which records to
+        // remove, and a hidden remainder invites them to believe they are finished.
+        //
+        // The count is deliberately a LOWER BOUND: an exact figure would mean scanning every
+        // withheld character of an attacker-controlled value. `hiddenUncounted` is what makes
+        // the copy honest about that ("at least N"), so it MUST be set whenever the scan
+        // stopped early. The previous version counted SEPARATORS rather than segments and
+        // could stop on its own budget while still reporting an exact-sounding figure, so 55
+        // records reported 4 withheld when 5 were (verified).
+        if (cursor < input.length) {
+          let hidden = 0;
+          let scan = cursor;
+          // Count SEGMENTS: a segment is a run of non-newline characters.
+          //
+          // BOTH loops are bounded. The segment count is capped by the line budget, and each
+          // segment's own walk is capped by `MAX_LITERAL_LINE_CHARS` — without that inner cap a
+          // remainder holding one very long newline-free line walked the whole string (20M
+          // chars ≈ 42ms, linear in attacker input), which silently undid the "bound WORK, not
+          // only output" guarantee the skip loop above exists to provide.
+          while (scan < input.length && hidden < MAX_LITERAL_LINES) {
+            while (scan < input.length && (input[scan] === '\n' || input[scan] === '\r')) {
+              scan += 1;
+            }
+            if (scan >= input.length) {
+              break;
+            }
+            hidden += 1;
+            const segmentLimit = scan + MAX_LITERAL_LINE_CHARS;
+            while (scan < input.length && scan < segmentLimit && input[scan] !== '\n' && input[scan] !== '\r') {
+              scan += 1;
+            }
+            if (scan < input.length && input[scan] !== '\n' && input[scan] !== '\r') {
+              // Gave up mid-segment, so anything past here is uncounted.
+              b.hiddenUncounted = true;
+              break;
+            }
+          }
+          // Anything left unscanned means the figure is a floor, not a total.
+          if (scan < input.length) {
+            b.hiddenUncounted = true;
+          }
+          b.hiddenLines += hidden;
+        }
         return;
       }
       nodes.push( /*#__PURE__*/React__default.createElement("p", {
@@ -6664,11 +6971,37 @@ const renderExtractedValue = (value, keyPrefix) => {
     }
     if ( /*#__PURE__*/React__default.isValidElement(input)) {
       var _input$key;
+      // Charged against the budget too: element leaves are nodes like any other, and an
+      // uncharged leaf type is an escape hatch — 5,000 object leaves previously rendered
+      // 5,000 lines with no notice.
+      if (literal) {
+        if (budgetExhausted(b)) {
+          b.hiddenLines += 1;
+          return;
+        }
+        b.lines -= 1;
+      }
       nodes.push( /*#__PURE__*/React__default.cloneElement(input, {
         key: (_input$key = input.key) !== null && _input$key !== void 0 ? _input$key : `${prefix}-element`
       }));
       return;
     }
+
+    // Numbers, booleans, objects. Stringified, so they are bounded and charged exactly like
+    // string leaves rather than bypassing the budget.
+    if (literal) {
+      if (budgetExhausted(b)) {
+        b.hiddenLines += 1;
+        return;
+      }
+      const text = sliceWholeCodePoints(String(input), Math.min(MAX_LITERAL_LINE_CHARS, b.chars));
+      b.lines -= 1;
+      b.chars -= text.length;
+      nodes.push( /*#__PURE__*/React__default.createElement("p", {
+        key: `${prefix}-fallback`
+      }, text));
+      return;
+    }
     nodes.push( /*#__PURE__*/React__default.createElement("p", {
       key: `${prefix}-fallback`
     }, String(input)));
@@ -6676,6 +7009,65 @@ const renderExtractedValue = (value, keyPrefix) => {
   process(value, keyPrefix);
   return nodes;
 };
+
+/**
+ * Wrap already-literal, newline-split nodes in a `CodeBlock`, one `CodeBlockLine` per record.
+ *
+ * Shared by every code-block path so they cannot drift apart: `CodeBlock` sets
+ * `white-space: normal`, so without one element per line multiple records flow together.
+ */
+const renderCodeBlock = nodes => /*#__PURE__*/React__default.createElement(CodeBlock, null, nodes.map((node, idx) => {
+  if ( /*#__PURE__*/React__default.isValidElement(node) && node.type === 'p') {
+    var _node$key;
+    return /*#__PURE__*/React__default.createElement(CodeBlockLine, {
+      key: (_node$key = node.key) !== null && _node$key !== void 0 ? _node$key : `code-line-${idx}`
+    }, node.props.children);
+  }
+  return node;
+}));
+
+/**
+ * Notice that the renderer withheld part of a literal value.
+ *
+ * The caps above are initial-render SAFETY limits, not a completeness guarantee: DNS defines
+ * no record-count limit for a name, a TXT RR may concatenate several 255-octet strings, and
+ * under RFC 9989 §4.10 every competing record is discarded — so dozens of short records are
+ * protocol-plausible and each withheld value is one the operator still has to delete.
+ *
+ * Reporting is therefore the minimum: truncating silently would tell someone the list is
+ * complete when it is not. A "copy all published records" action was built and REVERTED (see
+ * CHANGELOG) — it could not honour its own promise, so full-evidence access is tracked
+ * separately rather than half-delivered here.
+ *
+ * Rendered OUTSIDE the `CodeBlock` and as its own `LiteralTruncationNotice`, for a security
+ * reason rather than a stylistic one: inside the block it was structurally and visually
+ * identical to a record, so a zone publishing the literal text `[… 3 more records not shown]`
+ * produced an indistinguishable line (verified). Zone content and renderer commentary must
+ * not share a presentation. `data-testid` is stable so tests can assert the notice
+ * specifically, rather than matching prose an attacker could also publish.
+ */
+const renderTruncationNotice = (budget, t) => {
+  const parts = [];
+  if (budget.hiddenLines > 0) {
+    parts.push(t(budget.hiddenUncounted ? 'card.extracted.truncated-records-atleast' : 'card.extracted.truncated-records', {
+      count: budget.hiddenLines
+    }));
+  } else if (budget.hiddenUncounted) {
+    parts.push(t('card.extracted.truncated-records-uninspected'));
+  }
+
+  // Reported ALONGSIDE the hidden count, not instead of it: a payload that both shortened
+  // every visible record and hid further ones must not announce only one of the two.
+  if (budget.shortenedLines) {
+    parts.push(t('card.extracted.truncated-record-length'));
+  }
+  if (!parts.length) {
+    return null;
+  }
+  return /*#__PURE__*/React__default.createElement(LiteralTruncationNotice, {
+    "data-testid": "extracted-truncation-notice"
+  }, parts.join(' '));
+};
 const ExtractedItem = _ref2 => {
   let {
     type,
@@ -6684,7 +7076,8 @@ const ExtractedItem = _ref2 => {
     text,
     inline = true,
     useCodeBlock = false,
-    extractionBox
+    extractionBox,
+    literalBudget
   } = _ref2;
   // Get translated caption for extraction box
   const {
@@ -6695,29 +7088,25 @@ const ExtractedItem = _ref2 => {
   // Parse label if it's a string with glossary markdown
   const parsedLabel = typeof label === 'string' ? parseGlossaryMarkdown(label) : label;
 
-  // Strip newlines from text if it's a string and we're using code block
-  const cleanedText = useCodeBlock && typeof text === 'string' ? text.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim() : text;
-  const renderedText = renderExtractedValue(cleanedText, 'extracted-item-text');
+  // DS-115: a code-block value may legitimately be MULTIPLE records (e.g. a domain that
+  // publishes two competing `_dmarc` TXT records). Collapsing newlines into spaces ran them
+  // together into one flowed line with no visible boundary, which is precisely the condition
+  // the card exists to report. `renderExtractedValue`'s literal mode splits every string leaf
+  // on newlines (including strings nested in arrays) so each record renders on its own line.
+  const budget = literalBudget !== null && literalBudget !== void 0 ? literalBudget : createLiteralBudget();
+  const renderedText = renderExtractedValue(text, 'extracted-item-text', useCodeBlock, budget);
   const icon = getIcon({
     type,
     theme
   });
 
-  // Wrap in CodeBlock if needed
-  const displayText = useCodeBlock ? /*#__PURE__*/React__default.createElement(CodeBlock, null, typeof renderedText === 'string' ? renderedText : /*#__PURE__*/React__default.createElement(React__default.Fragment, null, renderedText.map(node => {
-    // Extract text content from p tags and flatten
-    if ( /*#__PURE__*/React__default.isValidElement(node) && node.type === 'p') {
-      const children = node.props.children;
-
-      // If children is a string, strip ALL newlines aggressively
-      const cleanedChildren = typeof children === 'string' ? children.replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim() : children;
-      return cleanedChildren;
-    }
-    return node;
-  }))) : renderedText;
+  // Wrap in CodeBlock if needed. The truncation notice sits OUTSIDE the block — see
+  // `renderTruncationNotice` on why it must never be a `CodeBlockLine`.
+  const displayText = useCodeBlock ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, renderCodeBlock(renderedText), renderTruncationNotice(budget, t)) : renderedText;
+  const hasContent = renderedText.length > 0;
   const content = /*#__PURE__*/React__default.createElement(SignalCardInfoBox$1, null, /*#__PURE__*/React__default.createElement(InfoItemRow, null, icon ? /*#__PURE__*/React__default.createElement(InfoItemIcon, null, icon) : null, /*#__PURE__*/React__default.createElement(InfoItemContent, null, /*#__PURE__*/React__default.createElement(InfoItemLabel, {
     $inline: true
-  }, parsedLabel), inline && renderedText.length ? displayText : null)), !inline && renderedText.length ? /*#__PURE__*/React__default.createElement(InfoItemSubtexts, null, displayText) : null);
+  }, parsedLabel), inline && hasContent ? displayText : null)), !inline && hasContent ? /*#__PURE__*/React__default.createElement(InfoItemSubtexts, null, displayText) : null);
 
   // Wrap in extraction box if specified
   if (extractionBox) {
@@ -6727,9 +7116,12 @@ const ExtractedItem = _ref2 => {
   }
   return content;
 };
-function renderGridItem(item, idx, t) {
+function renderGridItem(item, idx, t, budget) {
   const parsedLabel = typeof item.label === 'string' ? parseGlossaryMarkdown(item.label) : item.label;
-  const renderedText = renderExtractedValue(item.text, `grid-item-${idx}`);
+  // DS-115: code-block values are attacker-controlled DNS data, so render them literally —
+  // same trust model as `ExtractedItem`. Without this the grid path fed raw TXT records
+  // through `parseGlossaryMarkdown`, which turns `[text](https://...)` into a real anchor.
+  const renderedText = renderExtractedValue(item.text, `grid-item-${idx}`, !!item.useCodeBlock, budget);
   const icon = getIcon({
     type: item.type,
     theme: item.theme
@@ -6749,7 +7141,7 @@ function renderGridItem(item, idx, t) {
       display: 'inline-flex'
     }
   }, icon))) : null;
-  const displayValue = item.useCodeBlock ? /*#__PURE__*/React__default.createElement(CodeBlock, null, renderedText) : /*#__PURE__*/React__default.createElement(GridValue, null, renderedText, alignmentIcon);
+  const displayValue = item.useCodeBlock ? /*#__PURE__*/React__default.createElement(React__default.Fragment, null, renderCodeBlock(renderedText), renderTruncationNotice(budget, t)) : /*#__PURE__*/React__default.createElement(GridValue, null, renderedText, alignmentIcon);
   return /*#__PURE__*/React__default.createElement(React__default.Fragment, {
     key: idx
   }, /*#__PURE__*/React__default.createElement(GridLabel, null, icon && !item.tooltipKey ? /*#__PURE__*/React__default.createElement("span", {
@@ -6768,6 +7160,15 @@ const ExtractedCategoryContent = _ref3 => {
   const {
     t
   } = useSignalCardTranslation('investigate');
+  // ONE budget per category render: upstream emits one item per candidate group, so a
+  // per-item budget let 20 groups render 20 x 50 lines with 20 separate notices.
+  //
+  // The notice is emitted per ITEM rather than once per category. Hoisting it was attempted
+  // and reverted: the budget is mutated while the ITEMS render, and a parent cannot observe
+  // that — `<Body/>` is only an element when the parent returns, so the notice read a pristine
+  // budget and never appeared. Doing it properly means precomputing each category's preview
+  // and truncation state before rendering, which is tracked separately (see CHANGELOG).
+  const literalBudget = createLiteralBudget();
   const useGridLayout = category.categoryType === 'dmarc-domain' || category.categoryType === 'dmarc-policy' || category.categoryType === 'dkim-details';
   if (useGridLayout) {
     var _category$items, _category$items2;
@@ -6799,12 +7200,13 @@ const ExtractedCategoryContent = _ref3 => {
           text: text,
           inline: inline,
           useCodeBlock: useCodeBlock,
-          extractionBox: undefined
+          extractionBox: undefined,
+          literalBudget: literalBudget
         });
       }), /*#__PURE__*/React__default.createElement(InfoItemsGrid, {
         $hasNonInlineItems: hasNonInlineItems,
         $insideCollapsible: true
-      }, (_category$items5 = category.items) === null || _category$items5 === void 0 ? void 0 : _category$items5.filter(item => item.inline !== false).map((item, idx) => renderGridItem(item, idx, t))));
+      }, (_category$items5 = category.items) === null || _category$items5 === void 0 ? void 0 : _category$items5.filter(item => item.inline !== false).map((item, idx) => renderGridItem(item, idx, t, literalBudget))));
     } else if (hasNonInlineItems) {
       var _category$items6, _category$items6$find, _category$items6$find2, _category$items7;
       // Only TXT records present
@@ -6830,7 +7232,8 @@ const ExtractedCategoryContent = _ref3 => {
           text: text,
           inline: inline,
           useCodeBlock: useCodeBlock,
-          extractionBox: undefined
+          extractionBox: undefined,
+          literalBudget: literalBudget
         });
       }));
     } else {
@@ -6841,7 +7244,7 @@ const ExtractedCategoryContent = _ref3 => {
       }, /*#__PURE__*/React__default.createElement(InfoItemsGrid, {
         $hasNonInlineItems: false,
         $insideCollapsible: true
-      }, (_category$items8 = category.items) === null || _category$items8 === void 0 ? void 0 : _category$items8.filter(item => item.inline !== false).map((item, idx) => renderGridItem(item, idx, t))));
+      }, (_category$items8 = category.items) === null || _category$items8 === void 0 ? void 0 : _category$items8.filter(item => item.inline !== false).map((item, idx) => renderGridItem(item, idx, t, literalBudget))));
     }
   }
 
@@ -6867,7 +7270,8 @@ const ExtractedCategoryContent = _ref3 => {
       text: text,
       inline: inline,
       useCodeBlock: useCodeBlock,
-      extractionBox: undefined
+      extractionBox: undefined,
+      literalBudget: literalBudget
     });
   })));
 };