undici 6.29.1

Source: https://github.com/nodejs/undici
Tag scanned: v6.29.1
Compared with: v6.29.0 (0 signals introduced since)
Files: 1872 scanned, 1674 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 57 info
Scan time: 27.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 35 of 35 warn and critical signals; 35 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-16 11:26

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info long-line docs/docs/api/api-lifecycle.md:61:1

line length 842 characters (raw pass, confidence 0.50)

The **idle** state is the initial state of a `Client` instance. While an `origin` is required for instantiating a `Client` instance, the underlying socket connection will not be established until a request is queued using [`Client.dispatch()`](Client.md#clientdispatchoptions-handlers). By calling `Client.dispatch()` di

info long-line lib/llhttp/constants.js:3:1

line length 585 characters (raw pass, confidence 0.50)

exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_

info dynamic-execution lib/web/fileapi/util.js:249:20

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      for (const chunk of bytes) {
        dataURL += btoa(decoder.write(chunk))
      }
```
info dynamic-execution lib/web/fileapi/util.js:252:18

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      dataURL += btoa(decoder.end())

      return dataURL
```
info ~~warn~~ → info by review encoding-base64 test/fetch/integrity.js:126:24

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
  await assert.rejects(fetch(`http://localhost:${server.address().port}`, {
    integrity: 'sha384-ypeBEsobvcr6wjGzmiPcTaeG7/gUfE5yuYB3ha/uSLs='
  }))
})
```
likely benign LLM, confidence 0.97 A sha384 Subresource Integrity hash literal in a fetch test.
Reasoning
The base64 string is a sha384 SRI digest passed as the integrity option in a fetch test. It is a normal hash literal, not an encoded payload.
info ~~warn~~ → info by review encoding-base64 test/fetch/integrity.js:148:24

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
  await assert.rejects(fetch(`http://localhost:${server.address().port}`, {
    integrity: 'sha512-ypeBEsobvcr6wjGzmiPcTaeG7/gUfE5yuYB3ha/uSLs='
  }))
})
```
likely benign LLM, confidence 0.97 A sha512 Subresource Integrity hash literal in a fetch test.
Reasoning
The base64 string is a sha512 SRI digest used as the integrity option in a test that expects rejection. It is ordinary test data.
info unicode-surrogate test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js:450:9

surrogate pair \uD801\uDC7E (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
```
  [[], '\u00E5', ''],
  [[], '\uD801\uDC7E', ''], // U+1047E
  [[], ' image/gif ', ' image/gif '],
  [[], '\timage/gif\t', ''],
```
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:93:8

17 consecutive `\xNN` escapes (entropy 3.6 bits/byte) (raw pass, confidence 0.65)
```
const kTestFallbackUtf8 = (
  "ABC~\xE2\x80\xBE\xC2\xA5\xE2\x89\x88\xC2\xA4\xEF\xBD\xA5\xE3\x83\xBB\xE2" +
    "\x80\xA2\xE2\x88\x99\xC2\xB7\xE2\x98\xBC\xE2\x98\x85\xE6\x98\x9F\xF0\x9F" +
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
```
likely benign LLM, confidence 0.95 UTF-8 byte escapes encoding a multi-byte test string in a WPT FileAPI helper.
Reasoning
The run of \xNN escapes spells out UTF-8 bytes of a Unicode test string for encoding tests in the WPT fixtures. This is deliberate test data, not obfuscation.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:94:6

18 consecutive `\xNN` escapes (entropy 3.5 bits/byte) (raw pass, confidence 0.65)
```
  "ABC~\xE2\x80\xBE\xC2\xA5\xE2\x89\x88\xC2\xA4\xEF\xBD\xA5\xE3\x83\xBB\xE2" +
    "\x80\xA2\xE2\x88\x99\xC2\xB7\xE2\x98\xBC\xE2\x98\x85\xE6\x98\x9F\xF0\x9F" +
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
    "\xA2\xE3\x83\xBB\xEF\xBD\xA5\xC2\xA4\xE2\x89\x88\xC2\xA5\xE2\x80\xBE~XYZ"
```
likely benign LLM, confidence 0.95 Continuation of the UTF-8 byte-escaped test string in the WPT FileAPI helper.
Reasoning
Continuation of the same UTF-8 byte-escaped test string used to exercise encoding fallback behaviour. Legitimate fixture content.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/FileAPI/support/send-file-form-helper.js:96:6

17 consecutive `\xNN` escapes (entropy 3.7 bits/byte) (raw pass, confidence 0.65)
```
    "\x8C\x9F\xE6\x98\x9F\xE2\x98\x85\xE2\x98\xBC\xC2\xB7\xE2\x88\x99\xE2\x80" +
    "\xA2\xE3\x83\xBB\xEF\xBD\xA5\xC2\xA4\xE2\x89\x88\xC2\xA5\xE2\x80\xBE~XYZ"
);
```
likely benign LLM, confidence 0.95 Final segment of the UTF-8 byte-escaped test string in the WPT FileAPI helper.
Reasoning
Final segment of the same deliberate UTF-8 byte-escaped test string. Benign fixture data.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/dispatcher.js:260:29

`eval` called with a non-literal expression (ast pass, confidence 0.75)
```
      try {
        const value = await eval(task.fn).apply(null, task.args);
        response = JSON.stringify({
          status: 'success',
```
likely benign LLM, confidence 0.70 WPT test dispatcher evals a test function received from the harness.
Reasoning
The WPT testdriver executor evals task.fn sent by the test harness so it can run test functions in the page. This is the harness's designed behaviour in a test fixture, though evaluating received code is a risk outside test contexts.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/executor-service-worker.js:21:5

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
    let task = await receive(uuid);
    eval(`(async () => {${task}})()`);
  }
};
```
likely benign LLM, confidence 0.70 Service worker test executor evals received task code from the harness.
Reasoning
The service worker executor evals a task string from the test harness, wrapped in an async function. This is the harness's intended mechanism for running tests in workers.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/common/dispatcher/executor-worker.js:9:5

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
    let task = await receive(uuid);
    eval(`(async () => {${task}})()`);
  }
};
```
likely benign LLM, confidence 0.70 Worker test executor evals received task code from the harness.
Reasoning
The worker test executor evals a task string received from the harness, the same designed pattern as the other executors. Test-only code.
info dynamic-execution test/fixtures/wpt/common/security-features/resources/common.sub.js:1219:51

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
      .then(source => {
          return 'data:text/javascript;base64,' + btoa(source);
        });
  } else {
```
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/eventsource/resources/cors.py:9:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    environ = {u"__file__": path}
    exec(compile(open(path, u"r").read(), path, u'exec'), environ, environ)
    rv = environ[u"main"](request, response)
    return rv
```
likely benign LLM, confidence 0.75 WPT server handler execs a local test script file to dispatch the request.
Reasoning
This WPT python handler execs a script from a fixed test-resource path into a namespace and calls its main function. This is standard server-side test-handler loading, not malicious.
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/eventsource/resources/cors.py:9:10

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
    environ = {u"__file__": path}
    exec(compile(open(path, u"r").read(), path, u'exec'), environ, environ)
    rv = environ[u"main"](request, response)
    return rv
```
likely benign LLM, confidence 0.75 compile call paired with exec to load a local WPT test handler file.
Reasoning
The compile call is part of the same exec(compile(open(path))) loading of a local test resource. The path is a fixed fixture path, so this is benign.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/api/basic/integrity.sub.any.js:31:39

base64-like blob (86 bytes, compression ratio 1.13) (raw pass, confidence 0.60)
```
const topSha512wrongpadding = "sha512-D6yns0qxG0E7+TwkevZ4Jt5t7Iy3ugmAajG/dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg";
const topSha512base64url = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg==";
```
likely benign LLM, confidence 0.97 Test constant holding a sha512 SRI hash string with padding variants.
Reasoning
Raw base64 blob in a WPT test fixture for SRI integrity hash parsing; sha512 digests are expected here, and the variants (wrong padding, base64url) are deliberate test cases.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/api/basic/integrity.sub.any.js:32:72

base64-like blob (52 bytes, compression ratio 1.21) (raw pass, confidence 0.60)
```
const topSha512base64url = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg==";
const topSha512base64url_nopadding = "sha512-D6yns0qxG0E7-TwkevZ4Jt5t7Iy3ugmAajG_dlf6Pado1JqTyneKXICDiqFIkLMRExgtvg8PlxbKTkYfRejSOg";
```
likely benign LLM, confidence 0.97 Base64url sha512 integrity hash fixtures in a WPT fetch test.
Reasoning
The base64url sha512 constants are SRI hash fixtures used to test accepted and rejected encodings. Benign test data.
info ~~warn~~ → info by review encoding-hex test/fixtures/wpt/fetch/api/basic/text-utf8.any.js:53:20

18 consecutive `\xNN` escapes (entropy 3.9 bits/byte) (raw pass, confidence 0.65)
```
var utf8WithBOM = "\xef\xbb\xbf\xe4\xb8\x89\xe6\x9d\x91\xe3\x81\x8b\xe3\x81\xaa\xe5\xad\x90";
var utf8WithBOMAsURLParameter = "%EF%BB%BF%E4%B8%89%E6%9D%91%E3%81%8B%E3%81%AA%E5%AD%90";
var utf8WithoutBOM = "\xe4\xb8\x89\xe6\x9d\x91\xe3\x81\x8b\xe3\x81\xaa\xe5\xad\x90";
```
likely benign LLM, confidence 0.95 UTF-8 byte-escaped CJK test strings for WPT text decoding tests.
Reasoning
The \xNN escapes encode UTF-8 bytes of CJK test strings for checking BOM and encoding handling in WPT. Deliberate test fixture content.

info dynamic-execution test/fixtures/wpt/fetch/api/credentials/authentication-basic.any.js:5:49

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)

  promise_test(function(test) {
    var headers = { "Authorization": "Basic " + btoa(user + ":" + pass)};
    var requestInit = {"credentials": mode, "headers": headers};
    return fetch("../resources/authentication.py?realm=test", requestInit).then(function(resp) {

info dynamic-execution test/fixtures/wpt/fetch/api/credentials/authentication-redirection.any.js:4:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
const authorizationValue = "Basic " + btoa("user:pass");
async function getAuthorizationHeaderValue(url)
{
```

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:85:5

orphaned low surrogate \uDF06 (no preceding high surrogate) (token pass, confidence 0.65)

  ["𝌆", [34, 240, 157, 140, 134, 34]],
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:85:11

orphaned high surrogate \uD834 (no matching low surrogate) (token pass, confidence 0.65)

  ["𝌆", [34, 240, 157, 140, 134, 34]],
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];

info unicode-surrogate test/fixtures/wpt/fetch/api/response/response-static-json.any.js:86:5

orphaned low surrogate \uDEAD (no preceding high surrogate) (token pass, confidence 0.65)
```
  ["\uDF06\uD834", [34, 92, 117, 100, 102, 48, 54, 92, 117, 100, 56, 51, 52, 34]],
  ["\uDEAD", [34, 92, 117, 100, 101, 97, 100, 34]],
];
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:6:12

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
        b"Content-Dictionary",
        b":U5abz16WDg7b8KS93msLPpOB4Vbef1uRzoORYkJw9BY=:")

    # `br_d_data` and `zstd_d_data` are generated using the following commands:
```
likely benign LLM, confidence 0.96 Dictionary hash value used as a test header.
Reasoning
A base64 SHA-256 dictionary hash used in a Content-Dictionary header in a WPT test resource; expected test data.
info ~~warn~~ → info by review payload-bytes-literal test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:15:17

bytes literal contains 39 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
    # $ xxd -p /tmp/out.brd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    br_d_data = b"\xa1\x98\x01\x80\x62\xa4\x4c\x1d\xdf\x12\x84\x8c\xae\xc2\xca\x60\x22\x07\x6e\x81\x05\x14\xc9\xb7\xc3\x44\x8e\xbc\x16\xe0\x15\x0e\xec\xc1\xee\x34\x33\x3e\x0d"
    # $ zstd -o /tmp/out.zstdd -D /tmp/dict /tmp/data
```
likely benign LLM, confidence 0.93 Brotli-compressed test payload as a bytes literal.
Reasoning
Binary brotli test payload written as escaped bytes, with the generation commands documented in comments. Test fixture data, not an attack payload.
info ~~warn~~ → info by review encoding-escape-soup test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:15:19

39 consecutive `\xNN` escapes (entropy 5.3 bits/byte) (raw pass, confidence 0.80)
```
    # $ xxd -p /tmp/out.brd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    br_d_data = b"\xa1\x98\x01\x80\x62\xa4\x4c\x1d\xdf\x12\x84\x8c\xae\xc2\xca\x60\x22\x07\x6e\x81\x05\x14\xc9\xb7\xc3\x44\x8e\xbc\x16\xe0\x15\x0e\xec\xc1\xee\x34\x33\x3e\x0d"
    # $ zstd -o /tmp/out.zstdd -D /tmp/dict /tmp/data
```
likely benign LLM, confidence 0.85 Escaped brotli bytes for a WPT compression test.
Reasoning
Hex-escape soup is the same documented binary test payload; the escape pattern is expected for compressed test data.
info ~~warn~~ → info by review payload-bytes-literal test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:18:19

bytes literal contains 43 `\xNN` escapes (100% of content) — binary payload shape (ast pass, confidence 0.85)
```
    # $ xxd -p /tmp/out.zstdd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    zstd_d_data = b"\x28\xb5\x2f\xfd\x24\x34\xf5\x00\x00\x98\x63\x6f\x6d\x70\x72\x65\x73\x73\x65\x64\x61\x74\x61\x20\x75\x73\x69\x6e\x67\x03\x00\x59\xf9\x73\x54\x46\x27\x26\x10\x9e\x99\xf2\xbc"

    if b'content_encoding' in request.GET:
```
likely benign LLM, confidence 0.93 Zstd-compressed test payload as a bytes literal.
Reasoning
Zstd-compressed test payload with generation commands documented in comments; a standard fixture pattern for WPT.
info ~~warn~~ → info by review encoding-escape-soup test/fixtures/wpt/fetch/compression-dictionary/resources/compressed-data.py:18:21

43 consecutive `\xNN` escapes (entropy 5.0 bits/byte) (raw pass, confidence 0.80)
```
    # $ xxd -p /tmp/out.zstdd | tr -d '\n' | sed 's/$..$/\\x\1/g'
    zstd_d_data = b"\x28\xb5\x2f\xfd\x24\x34\xf5\x00\x00\x98\x63\x6f\x6d\x70\x72\x65\x73\x73\x65\x64\x61\x74\x61\x20\x75\x73\x69\x6e\x67\x03\x00\x59\xf9\x73\x54\x46\x27\x26\x10\x9e\x99\xf2\xbc"

    if b'content_encoding' in request.GET:
```
likely benign LLM, confidence 0.85 Escaped zstd bytes for a WPT compression test.
Reasoning
Same documented zstd test payload flagged by the raw escape heuristic; benign test data.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/compression-dictionary/resources/compression-dictionary-util.js:4:7

base64-like blob (44 bytes, compression ratio 1.25) (raw pass, confidence 0.60)
```
const kDefaultDictionaryHashBase64 =
    ':U5abz16WDg7b8KS93msLPpOB4Vbef1uRzoORYkJw9BY=:';
const kRegisterDictionaryPath = './resources/register-dictionary.py';
const kCompressedDataPath = './resources/compressed-data.py';
```
likely benign LLM, confidence 0.96 Base64 dictionary hash constant for compression-dictionary tests.
Reasoning
Default dictionary hash constant in a WPT utility file; expected test configuration.
info dynamic-execution test/fixtures/wpt/fetch/compression-dictionary/resources/compression-dictionary-util.js:29:16

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  const digest = await crypto.subtle.digest('SHA-256', encoded)
  return ':' + btoa(String.fromCharCode(...new Uint8Array(digest))) + ':';
}
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:12:35

base64-like blob (60 bytes, compression ratio 1.18) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoMiwgJyonKTwvc2NyaXB0Pg==",
    result: 2,
    name: "base64",
```
likely benign LLM, confidence 0.98 data: URL test input with base64-encoded HTML.
Reasoning
Standard data: URL with base64 payload in a WPT data-URL parsing test, decoding to a simple script.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:22:58

base64-like blob (55 bytes, compression ratio 1.20) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcml%09%20%20%0A%0C%0DwdD5wYXJlbnQucG9zdE1lc3NhZ2UoNiwgJyonKTwvc2NyaXB0Pg==",
    result: 6,
    name: "ASCII whitespace in the input is removed"
```
likely benign LLM, confidence 0.98 data: URL test input with whitespace inside base64.
Reasoning
Data URL test case deliberately including ASCII whitespace inside base64, per the test name. Expected WPT behavior.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:45:35

base64-like blob (59 bytes, compression ratio 1.19) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,PHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoMywgJyonKTwvc2NyaXB0Pg=",
    name: "base64 with incorrect padding",
  },
```
likely benign LLM, confidence 0.98 data: URL test input with malformed base64 padding.
Reasoning
Data URL test for base64 with incorrect padding, a deliberate edge case in a WPT suite.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/data-urls/navigate.window.js:53:36

base64-like blob (62 bytes, compression ratio 1.18) (raw pass, confidence 0.60)
```
  {
    input: "data:text/html;base64,%0BPHNjcmlwdD5wYXJlbnQucG9zdE1lc3NhZ2UoNywgJyonKTwvc2NyaXB0Pg==",
    name: "Vertical tab in the input leads to an error"
  }
```
likely benign LLM, confidence 0.98 data: URL test input containing a vertical tab.
Reasoning
Data URL test with a vertical tab in the base64 input, intended to produce an error. Expected WPT edge-case coverage.
info dynamic-execution test/fixtures/wpt/fetch/http-cache/http-cache.js:133:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  if ('cache' in config) init.cache = config['cache']
  init.headers.push(['Test-Requests', btoa(JSON.stringify(requests))])
  return init
}
```
info dynamic-execution test/fixtures/wpt/fetch/http-cache/http-cache.js:270:19

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
  } else {
    var content = btoa(Math.random() * Date.now())
    contentStore[csKey] = content
    return content
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/fetch/redirects/data.window.js:7:76

base64-like blob (136 bytes, compression ratio 0.90) (raw pass, confidence 0.60)
```
rces/redirect.py?location=data:image/png%3Bbase64,iVBORw0KGgoAAAANSUhEUgAAAIUAAABqCAIAAAAdqgU8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAF6SURBVHhe7dNBDQAADIPA%2Bje92eBxSQUQSLedlQzo0TLQonFWPVoGWjT%2BoUfLQIvGP/RoGWjR%2BIceLQMtGv/Qo2WgReMferQMtGj8Q4%2BWgRaNf%2BjRMtCi8Q89WgZaNP6hR8tAi8Y/9GgZaNH4
```
likely benign LLM, confidence 0.95 Base64-encoded PNG data URL embedded in a WPT fetch redirect test.
Reasoning
The blob is a base64-encoded PNG image (the 'iVBORw0KGgo' PNG header) used as a data URL in a web-platform-tests fetch redirect test fixture. This is ordinary test data, not obfuscation or a payload.
info ~~critical~~ → info by review dynamic-execution test/fixtures/wpt/resources/idlharness.js:2754:15

`eval` called with a non-literal expression (ast pass, confidence 0.75)
```
    {
        obj = eval(desc);
    }
    catch(e)
```
likely benign LLM, confidence 0.85 eval of an IDL descriptor expression inside the web-platform-tests IDL harness.
Reasoning
This is the WPT IDL harness, which evaluates IDL description strings with eval to build test objects. The eval is in a test framework fixture and is a known legitimate pattern there. Dynamic eval is still a risk in general, but the context is a bundled test library, not a supply-chain dropper.
info ~~warn~~ → info by review error-stack-inspection test/fixtures/wpt/resources/testharness.js:1613:26

`indexOf` called on `new Error().stack` — string-matching the call stack is the structural shape of sandbox/analyzer detection (ast pass, confidence 0.85)
```
                 if (typeof actual[p] === "object" && actual[p] !== null) {
                     if (stack.indexOf(actual[p]) === -1) {
                         check_equal(actual[p], expected[p], stack);
                     }
```
dismissed LLM, confidence 0.80 Recursive object comparison in the WPT testharness library checks a visited-stack array for cycles.
Reasoning
This is WPT's testharness cycle detection: it checks whether an object is already in a stack array, not the call stack. The Error().stack pattern is not shown here, so the flagged shape is a false positive for sandbox detection.

info whitespace-anomaly test/fixtures/wpt/resources/webidl2/lib/webidl2.js:2:1

file mixes tab and space indentation (8 tab-indented and 2451 space-indented lines) (raw pass, confidence 0.40)

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)

info unicode-surrogate test/fixtures/wpt/service-workers/cache-storage/cache-storage.https.any.js:206:34

orphaned high surrogate \uD800 (no matching low surrogate) (token pass, confidence 0.65)
```
promise_test(function(t) {
    var unpaired_name = 'unpaired\uD800';
    var converted_name = 'unpaired\uFFFD';
```
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:32:30

base64-like blob (72 bytes, compression ratio 1.15) (raw pass, confidence 0.60)
```
        headers.append((b"Content-Type", b"image/png"))
        body = decodebytes(b"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B"
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
```
likely benign LLM, confidence 0.90 Base64-encoded PNG image literal used as a test response body.
Reasoning
This is a small embedded PNG image used as a test response body in the WPT suite. Base64 image data is a legitimate test fixture pattern.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:33:30

base64-like blob (72 bytes, compression ratio 1.15) (raw pass, confidence 0.60)
```
        body = decodebytes(b"iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1B"
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
                           b"jBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=")
        return headers, body
```
likely benign LLM, confidence 0.90 Continuation of a base64-encoded PNG test image literal.
Reasoning
Continuation of the same embedded PNG test image in a WPT test fixture; no execution or exfiltration behaviour.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-access-control.py:34:30

base64-like blob (44 bytes, compression ratio 1.11) (raw pass, confidence 0.60)
```
                           b"AACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/KfgQLABKXJBqMG"
                           b"jBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=")
        return headers, body
```
likely benign LLM, confidence 0.90 Final chunk of an embedded base64 PNG test image.
Reasoning
Final chunk of the same PNG base64 literal in a WPT test resource, consistent with a legitimate image fixture.
info ~~warn~~ → info by review dynamic-execution test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:58:20

`atob` decodes a base64 value at runtime — common step before dynamic fetch or eval (ast pass, confidence 0.75)
```
    if (params['generate-png']) {
      var binary = atob(
          'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAA' +
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
```
likely benign LLM, confidence 0.90 atob decodes an embedded PNG image for a generated test response.
Reasoning
The atob call decodes a fixed PNG literal inside a branch that generates a PNG for a test worker. This is ordinary test-fixture code, not a dropper.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:60:12

base64-like blob (66 bytes, compression ratio 1.17) (raw pass, confidence 0.60)
```
          'iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAA' +
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
          'gQLABKXJBqMGjBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=');
      var array = new Uint8Array(binary.length);
```
likely benign LLM, confidence 0.90 Base64 PNG literal fragment used by a test worker.
Reasoning
Same embedded PNG base64 literal consumed by atob in a WPT worker test; legitimate image data.
info ~~warn~~ → info by review encoding-base64 test/fixtures/wpt/service-workers/service-worker/resources/fetch-rewrite-worker.js:61:12

base64-like blob (56 bytes, compression ratio 1.20) (raw pass, confidence 0.60)
```
          'RnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAAhSURBVDhPY3wro/Kf' +
          'gQLABKXJBqMGjBoAAqMGDLwBDAwAEsoCTFWunmQAAAAASUVORK5CYII=');
      var array = new Uint8Array(binary.length);
      for(var i = 0; i < binary.length; i++) {
```
likely benign LLM, confidence 0.90 Remaining base64 PNG literal fragment in a test worker.
Reasoning
Remaining fragment of the same PNG base64 literal in the WPT test worker; benign fixture data.
info ~~warn~~ → info by review dynamic-import test/fixtures/wpt/service-workers/service-worker/resources/no-dynamic-import.js:15:45

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  promise_test(
    (t) => promise_rejects_js(t, TypeError, import(url), "Import must reject"),
    name
  );
```
likely benign LLM, confidence 0.90 Test helper passes a URL to import() to verify that it rejects under the service worker policy.
Reasoning
The dynamic import is in a WPT test that deliberately checks import rejection behaviour for a URL parameter. It is a test of the platform, not malicious loading.
info unicode-surrogate test/fixtures/wpt/websockets/Close-reason-unpaired-surrogates.any.js:11:15

orphaned high surrogate \uD807 (no matching low surrogate) (token pass, confidence 0.65)
```
var replacementChar = "\uFFFD";
var reason = "\uD807";

wsocket.addEventListener('open', test.step_func(function(evt) {
```
info unicode-surrogate test/fixtures/wpt/websockets/Send-paired-surrogates.any.js:8:13

surrogate pair \uD801\uDC07 (non-scalar Unicode codepoints in string literal) (token pass, confidence 0.70)
```
var data = "\uD801\uDC07";
var wsocket = CreateWebSocket(false, false);
var isOpenCalled = false;
```
info unicode-surrogate test/fixtures/wpt/websockets/Send-unpaired-surrogates.any.js:8:13

orphaned high surrogate \uD807 (no matching low surrogate) (token pass, confidence 0.65)
```
var data = "\uD807";
var replacementChar = "\uFFFD";
var wsocket = CreateWebSocket(false, false);
```
info ~~warn~~ → info by review long-line test/fixtures/wpt/xhr/resources/over-1-meg.txt:1:1

line length 1160000 characters (raw pass, confidence 0.65)
```
abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
```
likely benign LLM, confidence 0.95 Large repetitive text file used as an XHR test payload.
Reasoning
A plain text test resource of repeated 'abcd' used to test XHR over 1 MB responses. A long line is expected for this file.
info ~~warn~~ → info by review narrow-file-charset test/fixtures/wpt/xhr/resources/over-1-meg.txt:1:1

file uses only 4 distinct printable characters ("abcd") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd
```
likely benign LLM, confidence 0.95 Repeated 'abcd' test payload flagged for narrow character set.
Reasoning
The narrow charset is the deliberate repetition of 'abcd' in a test payload file. It is not obfuscated code.
info unicode-surrogate test/fixtures/wpt/xhr/send-data-string-invalid-unicode.any.js:3:25

orphaned high surrogate \uD83D (no matching low surrogate) (token pass, confidence 0.65)
```
const LEFT_SURROGATE = '\ud83d';
const RIGHT_SURROGATE = '\udc94';
```
info unicode-surrogate test/fixtures/wpt/xhr/send-data-string-invalid-unicode.any.js:4:26

orphaned low surrogate \uDC94 (no preceding high surrogate) (token pass, confidence 0.65)
```
const LEFT_SURROGATE = '\ud83d';
const RIGHT_SURROGATE = '\udc94';

// Unmatched surrogates should be replaced with the unicode replacement
```
info dynamic-execution test/fixtures/wpt/xhr/xhr-authorization-redirect.any.js:4:39

`btoa` encodes a value as base64 at runtime — used in exfiltration patterns (ast pass, confidence 0.55)
```
const authorizationValue = "Basic " + btoa("user:pass");
function getAuthorizationHeaderValue(url)
{
```

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/nodejs/undici undici && cd undici
git checkout v6.29.1
disclude scan --severity info --diff v6.29.0 .